Merge branch 'master' into new-torrent

server/dlna/dlna.go

@@ -39,6 +39,7 @@ func Start() {
 		FriendlyName: getDefaultFriendlyName(),
 		NoTranscode:  true,
 		NoProbe:      true,
+		StallEventSubscribe: true,
 		Icons: []dms.Icon{
 			dms.Icon{
 				Width:      32,

server/dlna/list.go

@@ -9,29 +9,42 @@ import (
 	"time"
 
 	"github.com/anacrolix/dms/dlna"
-	"github.com/anacrolix/dms/dlna/dms"
 	"github.com/anacrolix/dms/upnpav"
 
 	"server/log"
 	"server/settings"
 	"server/torr"
 	"server/torr/state"
-	"server/utils"
 )
 
 func getTorrents() (ret []interface{}) {
 	torrs := torr.ListTorrent()
+	var vol = 0
 	for _, t := range torrs {
+		vol++
 		obj := upnpav.Object{
 			ID:          "%2F" + t.TorrentSpec.InfoHash.HexString(),
-			Restricted:  1,
 			ParentID:    "0",
-			Class:       "object.container.storageFolder",
 			Title:       t.Title,
+			Class:       "object.container.storageFolder",
+			Restricted:  1,
 			Icon:        t.Poster,
 			AlbumArtURI: t.Poster,
+			Date: upnpav.Timestamp{Time: time.Now()},
 		}
-		cnt := upnpav.Container{Object: obj}
+		cnt := upnpav.Container{Object: obj, ChildCount: 1}
+		ret = append(ret, cnt)
+	}
+	if vol == 0 {
+		obj := upnpav.Object{
+			ID:         "%2FNo Torrents",
+			ParentID:   "0",
+			Title:      "No Torrents",
+			Class:      "object.container.storageFolder",
+			Restricted: 1,
+			Date: upnpav.Timestamp{Time: time.Now()},
+		}
+		cnt := upnpav.Container{Object: obj, ChildCount: 1}
 		ret = append(ret, cnt)
 	}
 	return
@@ -57,12 +70,13 @@ func getTorrent(path, host string) (ret []interface{}) {
 	if torr.Files() == nil {
 		obj := upnpav.Object{
 			ID:         parent + "%2FLoad Torrent",
-			Restricted: 1,
 			ParentID:   parent,
-			Class:      "object.container.storageFolder",
 			Title:      "Load Torrent",
+			Class:      "object.container.storageFolder",
+			Restricted: 1,
+			Date: upnpav.Timestamp{Time: time.Now()},
 		}
-		cnt := upnpav.Container{Object: obj}
+		cnt := upnpav.Container{Object: obj, ChildCount: 1}
 		ret = append(ret, cnt)
 		return
 	}
@@ -122,26 +136,23 @@ func getLink(host, path string) string {
 }
 
 func getObjFromTorrent(path, parent, host string, torr *torr.Torrent, file *state.TorrentFileStat) (ret interface{}) {
-	// only playable files
-	if utils.GetMimeType(file.Path) == "*/*" {
+
+	mime, err := MimeTypeByPath(file.Path)
+	if err != nil {
+		log.TLogln("Can't detect mime type", err)	
 		return
 	}
-	mime, err := dms.MimeTypeByPath(file.Path)
-	if err != nil {
-		//return // this always err
-		if utils.GetMimeType(file.Path) == "video/*" {
-			mime = "video/mpeg"
-		} else {
-			mime = "audio/mpeg"
-		}
+	if !mime.IsMedia() {
+		return
 	}
 
 	obj := upnpav.Object{
 		ID:         parent + "%2F" + file.Path,
-		Restricted: 1,
 		ParentID:   parent,
-		Class:      "object.item." + mime.Type() + "Item",
 		Title:      file.Path,
+		Class:      "object.item." + mime.Type() + "Item",
+		Restricted: 1,
+		Date: upnpav.Timestamp{Time: time.Now()},
 	}
 
 	item := upnpav.Item{

server/dlna/mimetype.go

@@ -0,0 +1,127 @@
+package dlna
+
+import (
+	"log"
+	"mime"
+	"net/http"
+	"os"
+	"path"
+	"strings"
+
+)
+
+func init() {
+
+// Add a minimal number of mime types to augment go's built in types
+// for environments which don't have access to a mime.types file (e.g.
+// Termux on android)
+	for _, t := range []struct {
+		mimeType   string
+		extensions string
+	}{
+		{"audio/aac", ".aac"},
+		{"audio/flac", ".flac"},
+		{"audio/mpeg", ".mpga,.mpega,.mp2,.mp3,.m4a"},
+		{"audio/ogg", ".oga,.ogg,.opus,.spx"},
+		{"audio/opus", ".opus"},
+		{"audio/weba", ".weba"},
+		{"audio/x-wav", ".wav"},
+		{"image/bmp", ".bmp"},
+		{"image/gif", ".gif"},
+		{"image/jpeg", ".jpg,.jpeg"},
+		{"image/png", ".png"},
+		{"image/tiff", ".tiff,.tif"},
+		{"video/dv", ".dif,.dv"},
+		{"video/fli", ".fli"},
+		{"video/mpeg", ".mpeg,.mpg,.mpe"},
+		{"video/mp2t", ".ts,.m2ts,.mts"},
+		{"video/mp4", ".mp4"},
+		{"video/quicktime", ".qt,.mov"},
+		{"video/ogg", ".ogv"},
+		{"video/webm", ".webm"},
+		{"video/x-msvideo", ".avi"},
+		{"video/x-matroska", ".mpv,.mkv"},
+		{"text/srt", ".srt"},
+	} {
+		for _, ext := range strings.Split(t.extensions, ",") {
+			err := mime.AddExtensionType(ext, t.mimeType)
+			if err != nil {
+				panic(err)
+			}
+		}
+	}
+	if err := mime.AddExtensionType(".rmvb", "application/vnd.rn-realmedia-vbr"); err != nil {
+		log.Printf("Could not register application/vnd.rn-realmedia-vbr MIME type: %s", err)
+	}
+}
+
+// Example: "video/mpeg"
+type mimeType string
+
+// IsMedia returns true for media MIME-types
+func (mt mimeType) IsMedia() bool {
+	return mt.IsVideo() || mt.IsAudio() || mt.IsImage()
+}
+
+// IsVideo returns true for video MIME-types
+func (mt mimeType) IsVideo() bool {
+	return strings.HasPrefix(string(mt), "video/") || mt == "application/vnd.rn-realmedia-vbr"
+}
+
+// IsAudio returns true for audio MIME-types
+func (mt mimeType) IsAudio() bool {
+	return strings.HasPrefix(string(mt), "audio/")
+}
+
+// IsImage returns true for image MIME-types
+func (mt mimeType) IsImage() bool {
+	return strings.HasPrefix(string(mt), "image/")
+}
+
+// Returns the group "type", the part before the '/'.
+func (mt mimeType) Type() string {
+	return strings.SplitN(string(mt), "/", 2)[0]
+}
+
+// Returns the string representation of this MIME-type
+func (mt mimeType) String() string {
+	return string(mt)
+}
+
+// MimeTypeByPath determines the MIME-type of file at the given path
+func MimeTypeByPath(filePath string) (ret mimeType, err error) {
+	ret = mimeTypeByBaseName(path.Base(filePath))
+	if ret == "" {
+		ret, err = mimeTypeByContent(filePath)
+	}
+	if ret == "video/x-msvideo" {
+		ret = "video/avi"
+	} else if ret == "" {
+		ret = "application/octet-stream"
+	}
+	return
+}
+
+// Guess MIME-type from the extension, ignoring ".part".
+func mimeTypeByBaseName(name string) mimeType {
+	name = strings.TrimSuffix(name, ".part")
+	ext := path.Ext(name)
+	if ext != "" {
+		return mimeType(mime.TypeByExtension(ext))
+	}
+	return mimeType("")
+}
+
+// Guess the MIME-type by analysing the first 512 bytes of the file.
+func mimeTypeByContent(path string) (ret mimeType, err error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return
+	}
+	defer file.Close()
+	var data [512]byte
+	if n, err := file.Read(data[:]); err == nil {
+		ret = mimeType(http.DetectContentType(data[:n]))
+	}
+	return
+}

server/go.mod

@@ -2,7 +2,9 @@ module server
 
 go 1.17
 
-replace github.com/anacrolix/dms v1.2.2 => github.com/yourok/dms v0.0.0-20210826085116-42eca44e0aef
+replace (
+	github.com/anacrolix/dms v1.2.2 => github.com/tsynik/dms v0.0.0-20210902055723-0fcf49216c68
+)
 
 exclude github.com/willf/bitset v1.2.0
 

server/go.sum

@@ -715,8 +715,6 @@ github.com/willf/bloom v0.0.0-20170505221640-54e3b963ee16/go.mod h1:MmAltL9pDMNT
 github.com/willf/bloom v2.0.3+incompatible h1:QDacWdqcAUI1MPOwIQZRy9kOR7yxfyEmxX8Wdm2/JPA=
 github.com/willf/bloom v2.0.3+incompatible/go.mod h1:MmAltL9pDMNTrvUkxdg0k0q5I0suxmuwp3KbyrZLOZ8=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
-github.com/yourok/dms v0.0.0-20210826085116-42eca44e0aef h1:8W9j6a/BpZjss9p6GkD5xvmLtONhWkkWT3XoRPtje0g=
-github.com/yourok/dms v0.0.0-20210826085116-42eca44e0aef/go.mod h1:1GqMUla/yTV3GFjpKMpmdntkTl6aslGK3jfIksEwIdI=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
 go.etcd.io/bbolt v1.3.4/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ=