693 lines
17 KiB
Go
693 lines
17 KiB
Go
package vfs
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"image"
|
|
_ "image/gif"
|
|
_ "image/jpeg"
|
|
_ "image/png"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/alecthomas/chroma/v2"
|
|
"github.com/alecthomas/chroma/v2/formatters"
|
|
"github.com/alecthomas/chroma/v2/lexers"
|
|
"github.com/alecthomas/chroma/v2/styles"
|
|
)
|
|
|
|
var sgrRegexp = regexp.MustCompile(`\x1b\[([0-9;:]*)m`)
|
|
var sgrNumberRegexp = regexp.MustCompile(`\d+`)
|
|
|
|
type PreviewKind string
|
|
|
|
const (
|
|
PreviewKindEmpty PreviewKind = "empty"
|
|
PreviewKindDirectory PreviewKind = "directory"
|
|
PreviewKindText PreviewKind = "text"
|
|
PreviewKindImage PreviewKind = "image"
|
|
PreviewKindPDF PreviewKind = "pdf"
|
|
PreviewKindAudio PreviewKind = "audio"
|
|
PreviewKindVideo PreviewKind = "video"
|
|
PreviewKindBinary PreviewKind = "binary"
|
|
PreviewKindError PreviewKind = "error"
|
|
)
|
|
|
|
type Metadata struct {
|
|
Path string
|
|
Kind string
|
|
Size int64
|
|
SizeKnown bool
|
|
ModifiedAt string
|
|
CreatedAt string
|
|
Permissions string
|
|
ImageFormat string
|
|
ImageSize string
|
|
Extension string
|
|
|
|
// Extended preview metadata
|
|
Duration string
|
|
Bitrate string
|
|
AudioCodec string
|
|
VideoCodec string
|
|
SampleRate string
|
|
Channels string
|
|
PageCount string
|
|
Dimensions string
|
|
}
|
|
|
|
type Preview struct {
|
|
Kind PreviewKind
|
|
Title string
|
|
Body string
|
|
PlainBody string
|
|
Metadata Metadata
|
|
Entries []Entry
|
|
}
|
|
|
|
type PreviewOptions struct {
|
|
ShowHidden bool
|
|
DirsFirst bool
|
|
SortBy string
|
|
SortReverse bool
|
|
MaxPreviewBytes int64
|
|
DirectoryPreviewLimit int
|
|
HumanReadableSize bool
|
|
ThemeName string
|
|
UseNerdIcons bool
|
|
ImagePreviewWidth int
|
|
ImagePreviewHeight int
|
|
}
|
|
|
|
func BuildPreview(entry Entry, options PreviewOptions) Preview {
|
|
preview := Preview{
|
|
Kind: PreviewKindEmpty,
|
|
Title: entry.DisplayName(),
|
|
Metadata: Metadata{
|
|
Path: entry.Path,
|
|
Kind: kindLabel(entry),
|
|
Permissions: Permissions(entry.Mode),
|
|
ModifiedAt: ShortTime(entry.ModifiedAt),
|
|
CreatedAt: "n/a",
|
|
Extension: entry.Extension,
|
|
},
|
|
}
|
|
|
|
if entry.CreatedKnown {
|
|
preview.Metadata.CreatedAt = ShortTime(entry.CreatedAt)
|
|
}
|
|
|
|
if entry.IsDir {
|
|
preview.Kind = PreviewKindDirectory
|
|
preview.Metadata.Size = entry.Size
|
|
preview.Metadata.SizeKnown = entry.DirSizeKnown
|
|
preview.Body, preview.Entries = buildDirectoryPreview(entry.Path, options)
|
|
preview.PlainBody = preview.Body
|
|
return preview
|
|
}
|
|
|
|
preview.Metadata.Size = entry.Size
|
|
preview.Metadata.SizeKnown = true
|
|
|
|
file, err := os.Open(entry.Path)
|
|
if err != nil {
|
|
preview.Kind = PreviewKindError
|
|
preview.Body = fmt.Sprintf("Could not open file:\n\n%s", err)
|
|
preview.PlainBody = preview.Body
|
|
return preview
|
|
}
|
|
defer file.Close()
|
|
|
|
buffer := new(bytes.Buffer)
|
|
if _, err := io.CopyN(buffer, file, options.MaxPreviewBytes); err != nil && err != io.EOF {
|
|
preview.Kind = PreviewKindError
|
|
preview.Body = fmt.Sprintf("Could not read preview:\n\n%s", err)
|
|
preview.PlainBody = preview.Body
|
|
return preview
|
|
}
|
|
|
|
data := buffer.Bytes()
|
|
if format, dimensions, ok := DetectImage(data); ok {
|
|
preview.Kind = PreviewKindImage
|
|
preview.Metadata.ImageFormat = format
|
|
preview.Metadata.ImageSize = dimensions
|
|
inline := renderImageInlinePreview(entry.Path, options.ImagePreviewWidth, options.ImagePreviewHeight)
|
|
if inline != "" {
|
|
preview.Body = inline
|
|
}
|
|
preview.PlainBody = preview.Body
|
|
return preview
|
|
}
|
|
|
|
// Extended preview for PDF, audio, video via external utilities
|
|
if hasExt(pdfExtensions, entry.Extension) {
|
|
return buildPDFPreview(entry, options, preview)
|
|
}
|
|
if hasExt(audioExtensions, entry.Extension) {
|
|
return buildAudioPreview(entry, options, preview)
|
|
}
|
|
if hasExt(videoExtensions, entry.Extension) {
|
|
return buildVideoPreview(entry, options, preview)
|
|
}
|
|
|
|
if IsBinarySample(data) {
|
|
preview.Kind = PreviewKindBinary
|
|
preview.Body = "Binary file detected.\n\nSafe inline preview is disabled for this file type."
|
|
preview.PlainBody = preview.Body
|
|
return preview
|
|
}
|
|
|
|
preview.Kind = PreviewKindText
|
|
preview.PlainBody = strings.ReplaceAll(string(data), "\t", " ")
|
|
preview.Body = highlightText(entry.Path, preview.PlainBody, options.ThemeName)
|
|
return preview
|
|
}
|
|
|
|
func highlightText(path string, source string, themeName string) string {
|
|
lexer := lexers.Match(path)
|
|
if lexer == nil {
|
|
lexer = lexers.Analyse(source)
|
|
}
|
|
if lexer == nil {
|
|
return source
|
|
}
|
|
|
|
iterator, err := chroma.Coalesce(lexer).Tokenise(nil, source)
|
|
if err != nil {
|
|
return source
|
|
}
|
|
|
|
style := styles.Get(chromaStyleName(themeName))
|
|
if style == nil {
|
|
return source
|
|
}
|
|
style = styleWithoutBackground(style)
|
|
if style == nil {
|
|
return source
|
|
}
|
|
|
|
var output bytes.Buffer
|
|
if err := formatters.TTY16m.Format(&output, style, iterator); err != nil {
|
|
return source
|
|
}
|
|
return stripBackgroundSGR(output.String())
|
|
}
|
|
|
|
func styleWithoutBackground(base *chroma.Style) *chroma.Style {
|
|
if base == nil {
|
|
return nil
|
|
}
|
|
builder := base.Builder().Transform(func(entry chroma.StyleEntry) chroma.StyleEntry {
|
|
entry.Background = 0
|
|
return entry
|
|
})
|
|
stripped, err := builder.Build()
|
|
if err != nil {
|
|
return base
|
|
}
|
|
return stripped
|
|
}
|
|
|
|
func stripBackgroundSGR(text string) string {
|
|
return sgrRegexp.ReplaceAllStringFunc(text, func(seq string) string {
|
|
matches := sgrRegexp.FindStringSubmatch(seq)
|
|
if len(matches) != 2 {
|
|
return seq
|
|
}
|
|
filtered := filterSGRParams(matches[1])
|
|
if filtered == "" {
|
|
return ""
|
|
}
|
|
return "\x1b[" + filtered + "m"
|
|
})
|
|
}
|
|
|
|
func filterSGRParams(paramString string) string {
|
|
if paramString == "" {
|
|
return ""
|
|
}
|
|
|
|
raw := sgrNumberRegexp.FindAllString(paramString, -1)
|
|
if len(raw) == 0 {
|
|
return ""
|
|
}
|
|
codes := make([]int, 0, len(raw))
|
|
for _, token := range raw {
|
|
value, err := strconv.Atoi(token)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
codes = append(codes, value)
|
|
}
|
|
|
|
kept := make([]string, 0, len(codes))
|
|
for i := 0; i < len(codes); i++ {
|
|
code := codes[i]
|
|
|
|
if code == 0 {
|
|
// Do not hard-reset background to terminal default.
|
|
// Reset common text attributes + foreground only.
|
|
kept = append(kept, "39", "22", "23", "24", "59")
|
|
continue
|
|
}
|
|
|
|
if code == 49 || code == 7 || code == 27 || (code >= 40 && code <= 47) || (code >= 100 && code <= 107) {
|
|
continue
|
|
}
|
|
|
|
switch code {
|
|
case 48:
|
|
// Background color payloads:
|
|
// 48;5;n or 48;2;r;g;b (also appears in ':' form; parsed as the same int stream).
|
|
if i+1 < len(codes) {
|
|
mode := codes[i+1]
|
|
switch mode {
|
|
case 5:
|
|
i += 2
|
|
case 2:
|
|
i += 4
|
|
default:
|
|
i++
|
|
}
|
|
}
|
|
continue
|
|
case 38, 58:
|
|
// Preserve foreground (38) and underline color (58) payloads.
|
|
kept = append(kept, strconv.Itoa(code))
|
|
if i+1 < len(codes) {
|
|
mode := codes[i+1]
|
|
kept = append(kept, strconv.Itoa(mode))
|
|
switch mode {
|
|
case 5:
|
|
if i+2 < len(codes) {
|
|
kept = append(kept, strconv.Itoa(codes[i+2]))
|
|
}
|
|
i += 2
|
|
case 2:
|
|
if i+4 < len(codes) {
|
|
kept = append(kept,
|
|
strconv.Itoa(codes[i+2]),
|
|
strconv.Itoa(codes[i+3]),
|
|
strconv.Itoa(codes[i+4]),
|
|
)
|
|
}
|
|
i += 4
|
|
default:
|
|
i++
|
|
}
|
|
}
|
|
continue
|
|
}
|
|
|
|
kept = append(kept, strconv.Itoa(code))
|
|
}
|
|
|
|
return strings.Join(kept, ";")
|
|
}
|
|
|
|
func chromaStyleName(themeName string) string {
|
|
switch strings.ToLower(strings.TrimSpace(themeName)) {
|
|
case "catppuccin-mocha", "catppuccin-lavender":
|
|
return "catppuccin-mocha"
|
|
case "tokyo-night":
|
|
return "tokyonight-night"
|
|
case "gruvbox-dark", "gruvbox":
|
|
return "gruvbox"
|
|
case "nord-frost", "nord":
|
|
return "nord"
|
|
case "dracula":
|
|
return "dracula"
|
|
case "rose-pine":
|
|
return "rose-pine"
|
|
case "solarized-dark":
|
|
return "solarized-dark"
|
|
default:
|
|
return "catppuccin-mocha"
|
|
}
|
|
}
|
|
|
|
func buildDirectoryPreview(path string, options PreviewOptions) (string, []Entry) {
|
|
entries, err := ListDir(path, ListOptions{
|
|
ShowHidden: options.ShowHidden,
|
|
DirsFirst: options.DirsFirst,
|
|
SortBy: options.SortBy,
|
|
SortReverse: options.SortReverse,
|
|
})
|
|
if err != nil {
|
|
return fmt.Sprintf("Could not list directory:\n\n%s", err), nil
|
|
}
|
|
if len(entries) == 0 {
|
|
return "Directory is empty.", nil
|
|
}
|
|
|
|
// Return all entries as-is for column-based rendering.
|
|
// The text body is still generated for terminals that don't support
|
|
// the rich rendering, and as a fallback.
|
|
var lines []string
|
|
for _, entry := range entries {
|
|
if entry.IsParent {
|
|
continue
|
|
}
|
|
icon := previewIcon(entry, options.UseNerdIcons)
|
|
|
|
size := ""
|
|
if !entry.IsDir {
|
|
if options.HumanReadableSize {
|
|
size = HumanSize(entry.Size)
|
|
} else {
|
|
size = fmt.Sprintf("%d", entry.Size)
|
|
}
|
|
}
|
|
|
|
lines = append(lines, fmt.Sprintf("%s %-36s %12s %s", icon, entry.DisplayName(), size, ShortTime(entry.ModifiedAt)))
|
|
if len(lines) >= options.DirectoryPreviewLimit {
|
|
lines = append(lines, "…")
|
|
break
|
|
}
|
|
}
|
|
|
|
return strings.Join(lines, "\n"), entries
|
|
}
|
|
|
|
func previewIcon(entry Entry, useNerdIcons bool) string {
|
|
if !useNerdIcons {
|
|
switch entry.Category() {
|
|
case "directory":
|
|
return "[D]"
|
|
case "config":
|
|
return "[C]"
|
|
case "text":
|
|
return "[T]"
|
|
case "image":
|
|
return "[I]"
|
|
case "executable":
|
|
return "[X]"
|
|
case "archive":
|
|
return "[A]"
|
|
default:
|
|
return "[F]"
|
|
}
|
|
}
|
|
|
|
switch entry.Category() {
|
|
case "directory":
|
|
return ""
|
|
case "config":
|
|
return ""
|
|
case "text":
|
|
return ""
|
|
case "image":
|
|
return ""
|
|
case "executable":
|
|
return ""
|
|
case "archive":
|
|
return ""
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func renderImageInlinePreview(path string, width int, height int) string {
|
|
return ""
|
|
}
|
|
|
|
func findTool(name string) string {
|
|
path, err := exec.LookPath(name)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
return path
|
|
}
|
|
|
|
func buildPDFPreview(entry Entry, options PreviewOptions, base Preview) Preview {
|
|
pdftotext := findTool("pdftotext")
|
|
if pdftotext == "" {
|
|
base.Kind = PreviewKindBinary
|
|
base.Body = "PDF file detected.\nInstall poppler-utils (pdftotext) for text preview."
|
|
base.PlainBody = base.Body
|
|
return base
|
|
}
|
|
|
|
cmd := exec.Command(pdftotext, "-layout", "-nopgbrk", entry.Path, "-")
|
|
out, err := cmd.Output()
|
|
if err != nil {
|
|
base.Kind = PreviewKindError
|
|
base.Body = fmt.Sprintf("pdftotext error:\n\n%s", err)
|
|
base.PlainBody = base.Body
|
|
return base
|
|
}
|
|
|
|
text := string(out)
|
|
if int64(len(text)) > options.MaxPreviewBytes {
|
|
text = text[:options.MaxPreviewBytes]
|
|
}
|
|
|
|
// Get page count via pdfinfo if available
|
|
pdfinfo := findTool("pdfinfo")
|
|
if pdfinfo != "" {
|
|
infoCmd := exec.Command(pdfinfo, entry.Path)
|
|
if infoOut, err := infoCmd.Output(); err == nil {
|
|
for _, line := range strings.Split(string(infoOut), "\n") {
|
|
if strings.HasPrefix(strings.ToLower(line), "pages:") {
|
|
base.Metadata.PageCount = strings.TrimSpace(strings.TrimPrefix(line[5:], ":"))
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
base.Kind = PreviewKindPDF
|
|
base.PlainBody = text
|
|
base.Body = highlightText(entry.Path, text, options.ThemeName)
|
|
return base
|
|
}
|
|
|
|
func buildAudioPreview(entry Entry, options PreviewOptions, base Preview) Preview {
|
|
ffprobe := findTool("ffprobe")
|
|
if ffprobe == "" {
|
|
base.Kind = PreviewKindBinary
|
|
base.Body = "Audio file detected.\nInstall ffmpeg (ffprobe) for metadata preview."
|
|
base.PlainBody = base.Body
|
|
return base
|
|
}
|
|
|
|
cmd := exec.Command(ffprobe,
|
|
"-v", "quiet",
|
|
"-print_format", "json",
|
|
"-show_format",
|
|
"-show_streams",
|
|
entry.Path,
|
|
)
|
|
out, err := cmd.Output()
|
|
if err != nil {
|
|
base.Kind = PreviewKindError
|
|
base.Body = fmt.Sprintf("ffprobe error:\n\n%s", err)
|
|
base.PlainBody = base.Body
|
|
return base
|
|
}
|
|
|
|
var info struct {
|
|
Format struct {
|
|
Duration string `json:"duration"`
|
|
Bitrate string `json:"bit_rate"`
|
|
} `json:"format"`
|
|
Streams []struct {
|
|
CodecType string `json:"codec_type"`
|
|
CodecName string `json:"codec_name"`
|
|
SampleRate string `json:"sample_rate"`
|
|
Channels int `json:"channels"`
|
|
} `json:"streams"`
|
|
}
|
|
if err := json.Unmarshal(out, &info); err != nil {
|
|
base.Kind = PreviewKindError
|
|
base.Body = fmt.Sprintf("Could not parse ffprobe output:\n\n%s", err)
|
|
base.PlainBody = base.Body
|
|
return base
|
|
}
|
|
|
|
// Format duration
|
|
if info.Format.Duration != "" {
|
|
if secs, err := strconv.ParseFloat(info.Format.Duration, 64); err == nil {
|
|
mins := int(secs) / 60
|
|
secsRem := int(secs) % 60
|
|
base.Metadata.Duration = fmt.Sprintf("%d:%02d", mins, secsRem)
|
|
}
|
|
}
|
|
|
|
if info.Format.Bitrate != "" {
|
|
if bps, err := strconv.ParseInt(info.Format.Bitrate, 10, 64); err == nil {
|
|
base.Metadata.Bitrate = fmt.Sprintf("%d kbps", bps/1000)
|
|
}
|
|
}
|
|
|
|
for _, stream := range info.Streams {
|
|
if stream.CodecType == "audio" {
|
|
base.Metadata.AudioCodec = stream.CodecName
|
|
if stream.SampleRate != "" {
|
|
base.Metadata.SampleRate = stream.SampleRate + " Hz"
|
|
}
|
|
switch stream.Channels {
|
|
case 1:
|
|
base.Metadata.Channels = "mono"
|
|
case 2:
|
|
base.Metadata.Channels = "stereo"
|
|
case 6:
|
|
base.Metadata.Channels = "5.1"
|
|
case 8:
|
|
base.Metadata.Channels = "7.1"
|
|
default:
|
|
base.Metadata.Channels = fmt.Sprintf("%d ch", stream.Channels)
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
var lines []string
|
|
lines = append(lines, fmt.Sprintf(" Duration: %s", base.Metadata.Duration))
|
|
if base.Metadata.Bitrate != "" {
|
|
lines = append(lines, fmt.Sprintf(" Bitrate: %s", base.Metadata.Bitrate))
|
|
}
|
|
if base.Metadata.AudioCodec != "" {
|
|
lines = append(lines, fmt.Sprintf(" Codec: %s", base.Metadata.AudioCodec))
|
|
}
|
|
if base.Metadata.SampleRate != "" {
|
|
lines = append(lines, fmt.Sprintf(" Rate: %s", base.Metadata.SampleRate))
|
|
}
|
|
if base.Metadata.Channels != "" {
|
|
lines = append(lines, fmt.Sprintf(" Channels: %s", base.Metadata.Channels))
|
|
}
|
|
|
|
base.Kind = PreviewKindAudio
|
|
base.Body = fmt.Sprintf("🎵 Audio File\n\n%s", strings.Join(lines, "\n"))
|
|
base.PlainBody = fmt.Sprintf("Audio File\n\nDuration: %s\nBitrate: %s\nCodec: %s\nRate: %s\nChannels: %s",
|
|
base.Metadata.Duration, base.Metadata.Bitrate, base.Metadata.AudioCodec,
|
|
base.Metadata.SampleRate, base.Metadata.Channels)
|
|
return base
|
|
}
|
|
|
|
func buildVideoPreview(entry Entry, options PreviewOptions, base Preview) Preview {
|
|
ffprobe := findTool("ffprobe")
|
|
if ffprobe == "" {
|
|
base.Kind = PreviewKindBinary
|
|
base.Body = "Video file detected.\nInstall ffmpeg (ffprobe) for metadata preview."
|
|
base.PlainBody = base.Body
|
|
return base
|
|
}
|
|
|
|
cmd := exec.Command(ffprobe,
|
|
"-v", "quiet",
|
|
"-print_format", "json",
|
|
"-show_format",
|
|
"-show_streams",
|
|
entry.Path,
|
|
)
|
|
out, err := cmd.Output()
|
|
if err != nil {
|
|
base.Kind = PreviewKindError
|
|
base.Body = fmt.Sprintf("ffprobe error:\n\n%s", err)
|
|
base.PlainBody = base.Body
|
|
return base
|
|
}
|
|
|
|
var info struct {
|
|
Format struct {
|
|
Duration string `json:"duration"`
|
|
Bitrate string `json:"bit_rate"`
|
|
} `json:"format"`
|
|
Streams []struct {
|
|
CodecType string `json:"codec_type"`
|
|
CodecName string `json:"codec_name"`
|
|
Width int `json:"width"`
|
|
Height int `json:"height"`
|
|
} `json:"streams"`
|
|
}
|
|
if err := json.Unmarshal(out, &info); err != nil {
|
|
base.Kind = PreviewKindError
|
|
base.Body = fmt.Sprintf("Could not parse ffprobe output:\n\n%s", err)
|
|
base.PlainBody = base.Body
|
|
return base
|
|
}
|
|
|
|
// Format duration
|
|
if info.Format.Duration != "" {
|
|
if secs, err := strconv.ParseFloat(info.Format.Duration, 64); err == nil {
|
|
hrs := int(secs) / 3600
|
|
mins := (int(secs) % 3600) / 60
|
|
secsRem := int(secs) % 60
|
|
if hrs > 0 {
|
|
base.Metadata.Duration = fmt.Sprintf("%d:%02d:%02d", hrs, mins, secsRem)
|
|
} else {
|
|
base.Metadata.Duration = fmt.Sprintf("%d:%02d", mins, secsRem)
|
|
}
|
|
}
|
|
}
|
|
|
|
if info.Format.Bitrate != "" {
|
|
if bps, err := strconv.ParseInt(info.Format.Bitrate, 10, 64); err == nil {
|
|
base.Metadata.Bitrate = fmt.Sprintf("%d kbps", bps/1000)
|
|
}
|
|
}
|
|
|
|
for _, stream := range info.Streams {
|
|
switch stream.CodecType {
|
|
case "video":
|
|
base.Metadata.VideoCodec = stream.CodecName
|
|
if stream.Width > 0 && stream.Height > 0 {
|
|
base.Metadata.Dimensions = fmt.Sprintf("%dx%d", stream.Width, stream.Height)
|
|
}
|
|
case "audio":
|
|
if base.Metadata.AudioCodec == "" {
|
|
base.Metadata.AudioCodec = stream.CodecName
|
|
}
|
|
}
|
|
}
|
|
|
|
var lines []string
|
|
lines = append(lines, fmt.Sprintf(" Duration: %s", base.Metadata.Duration))
|
|
if base.Metadata.Bitrate != "" {
|
|
lines = append(lines, fmt.Sprintf(" Bitrate: %s", base.Metadata.Bitrate))
|
|
}
|
|
if base.Metadata.VideoCodec != "" {
|
|
lines = append(lines, fmt.Sprintf(" Video: %s", base.Metadata.VideoCodec))
|
|
}
|
|
if base.Metadata.Dimensions != "" {
|
|
lines = append(lines, fmt.Sprintf(" Resolution: %s", base.Metadata.Dimensions))
|
|
}
|
|
if base.Metadata.AudioCodec != "" {
|
|
lines = append(lines, fmt.Sprintf(" Audio: %s", base.Metadata.AudioCodec))
|
|
}
|
|
|
|
base.Kind = PreviewKindVideo
|
|
base.Body = fmt.Sprintf("🎬 Video File\n\n%s", strings.Join(lines, "\n"))
|
|
base.PlainBody = fmt.Sprintf("Video File\n\nDuration: %s\nBitrate: %s\nVideo: %s\nResolution: %s\nAudio: %s",
|
|
base.Metadata.Duration, base.Metadata.Bitrate, base.Metadata.VideoCodec,
|
|
base.Metadata.Dimensions, base.Metadata.AudioCodec)
|
|
return base
|
|
}
|
|
|
|
func DetectImage(data []byte) (string, string, bool) {
|
|
cfg, format, err := image.DecodeConfig(bytes.NewReader(data))
|
|
if err != nil {
|
|
return "", "", false
|
|
}
|
|
return format, fmt.Sprintf("%dx%d", cfg.Width, cfg.Height), true
|
|
}
|
|
|
|
func kindLabel(entry Entry) string {
|
|
switch {
|
|
case entry.IsParent:
|
|
return "parent"
|
|
case entry.IsDir:
|
|
return "directory"
|
|
case entry.Extension != "":
|
|
return "file"
|
|
default:
|
|
return strings.TrimPrefix(filepath.Ext(entry.Name), ".")
|
|
}
|
|
}
|