do not filter out m3u8

Update yt-dlp to 2025.01.12 from 2024.12.23

.github/workflows/push.yml

@@ -1,6 +1,10 @@
 name: Build on push and PRs
 
-on: [push,pull_request]
+on:
+  push:
+    branches:
+      - "master"
+  pull_request:
 
 jobs:
   build:

Dockerfile

@@ -1,17 +1,23 @@
 # bump: golang /GOLANG_VERSION=([\d.]+)/ docker:golang|^1
 # bump: golang link "Release notes" https://golang.org/doc/devel/release.html
-ARG GOLANG_VERSION=1.16.5
-# bump: youtube-dl /YDL_VERSION=([\d.]+)/ https://github.com/ytdl-org/youtube-dl.git|/^\d/|sort
-# bump: youtube-dl link "Release notes" https://github.com/ytdl-org/youtube-dl/releases/tag/$LATEST
-ARG YDL_VERSION=2021.06.06
+ARG GOLANG_VERSION=1.23.4
+# bump: yt-dlp /YT_DLP=([\d.-]+)/ https://github.com/yt-dlp/yt-dlp.git|/^\d/|sort
+# bump: yt-dlp link "Release notes" https://github.com/yt-dlp/yt-dlp/releases/tag/$LATEST
+ARG YT_DLP=2025.01.12
 
-FROM golang:$GOLANG_VERSION
-ARG YDL_VERSION
+FROM golang:$GOLANG_VERSION AS base
+ARG YT_DLP
 
 RUN \
-  curl -L -o /usr/local/bin/youtube-dl https://yt-dl.org/downloads/$YDL_VERSION/youtube-dl && \
-  chmod a+x /usr/local/bin/youtube-dl
+  apt-get update -q && \
+  apt-get install -y -q python-is-python3 && \
+  curl -L https://github.com/yt-dlp/yt-dlp/releases/download/$YT_DLP/yt-dlp -o /usr/local/bin/yt-dlp && \
+  chmod a+x /usr/local/bin/yt-dlp && \
+  apt-get install -y ffmpeg
 
+FROM base AS dev
+
+FROM base
 WORKDIR /src
 COPY go.* *.go ./
 COPY cmd cmd

README.md

@@ -1,15 +1,19 @@
 ## goutubedl
 
-Go wrapper for [youtube-dl](https://github.com/ytdl-org/youtube-dl). API documentation can be found at [godoc.org](https://pkg.go.dev/github.com/wader/goutubedl?tab=doc).
+Go wrapper for
+[youtube-dl](https://github.com/ytdl-org/youtube-dl) and
+[yt-dlp](https://github.com/yt-dlp/yt-dlp).
+Currently only tested and developed using yt-dlp.
+API documentation can be found at [godoc.org](https://pkg.go.dev/gitea.kaz62.ru/dilap54/goutubedl?tab=doc).
 
-See [youtube-dl documentation](https://github.com/ytdl-org/youtube-dl) for how to
-install and what is recommended to install in addition to youtube-dl.
+See [yt-dlp documentation](https://github.com/yt-dlp/yt-dlp) for how to
+install and what is recommended to install in addition to yt-dl.
 
-goutubedl default uses `PATH` to find youtube-dl but it can be configured with the `goutubedl.Path`
-variable.
+goutubedl default uses `PATH` to find `youtube-dl` or `yt-dlp` (in that order) but can be configured with the
+`goutubedl.Path` variable.
 
-Due to the nature and frequent updates of youtube-dl only the latest version
-is tested. But it seems to work well with older versions also.
+Due to the nature of and frequent updates of yt-dl only the latest version is tested.
+But it seems to work well with older versions also.
 
 ### Usage
 
@@ -23,7 +27,7 @@ import (
 	"log"
 	"os"
 
-	"github.com/wader/goutubedl"
+	"gitea.kaz62.ru/dilap54/goutubedl"
 )
 
 func main() {
@@ -49,10 +53,20 @@ func main() {
 See [goutubedl cmd tool](cmd/goutubedl/main.go) or [ydls](https://github.com/wader/ydls)
 for usage examples.
 
+### Default options and cache
+
+#### .netrc
+
+goutubedl by default uses `--netrc` to use `~/.netrc` authentication data.
+
+#### Cache directory
+
+yt-dlp stores various extractor session data to speed up things in `${XDG_CACHE_HOME}/yt-dlp` (usually `~/.cache/yt-dlp`). You might want to preverse this directory if your running things in ephemeral conatiners etc.
+
 ### Development
 
 ```sh
-docker build -t goutubedl-dev .
+docker build --target dev -t goutubedl-dev .
 docker run --rm -ti -v "$PWD:$PWD" -w "$PWD" goutubedl-dev
 go test -v -race -cover
 ```

cmd/example/main.go

@@ -6,7 +6,7 @@ import (
 	"log"
 	"os"
 
-	"github.com/wader/goutubedl"
+	"gitea.kaz62.ru/dilap54/goutubedl"
 )
 
 func main() {

cmd/goutubedl/main.go

@@ -7,25 +7,36 @@ import (
 	"io"
 	"log"
 	"os"
+	"os/exec"
 
-	"github.com/wader/goutubedl"
+	"gitea.kaz62.ru/dilap54/goutubedl"
 )
 
 var dumpFlag = flag.Bool("J", false, "Dump JSON")
 var typeFlag = flag.String("t", "any", "Type")
 
 func main() {
+	goutubedl.Path = "yt-dlp"
+
 	log.SetFlags(0)
 	flag.Parse()
 
-	optType, _ := goutubedl.TypeFromString[*typeFlag]
-	result, err := goutubedl.New(context.Background(), flag.Arg(0), goutubedl.Options{Type: optType})
+	optType := goutubedl.TypeFromString[*typeFlag]
+	result, err := goutubedl.New(
+		context.Background(),
+		flag.Arg(0),
+		goutubedl.Options{
+			Type:     optType,
+			DebugLog: log.Default(),
+			StderrFn: func(cmd *exec.Cmd) io.Writer { return os.Stderr },
+		},
+	)
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	if *dumpFlag {
-		json.NewEncoder(os.Stdout).Encode(result.Info)
+		_ = json.NewEncoder(os.Stdout).Encode(result.Info)
 		return
 	}
 
@@ -44,6 +55,8 @@ func main() {
 		log.Fatal(err)
 	}
 	defer f.Close()
-	io.Copy(f, dr)
+	if _, err := io.Copy(f, dr); err != nil {
+		log.Fatal(err)
+	}
 	dr.Close()
 }

go.mod

@@ -1,4 +1,4 @@
-module github.com/wader/goutubedl
+module gitea.kaz62.ru/dilap54/goutubedl
 
 go 1.12
 

goutubedl.go

@@ -9,7 +9,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net/http"
 	"os"
 	"os/exec"
@@ -18,8 +17,22 @@ import (
 	"strings"
 )
 
-// Path to youtube-dl binary. Default look for "youtube-dl" in PATH.
-var Path = "youtube-dl"
+// Path to youtube-dl binary. If not set look for "youtube-dl" then "yt-dlp" in PATH.
+var Path = ""
+
+func ProbePath() string {
+	if Path != "" {
+		return Path
+	}
+
+	for _, n := range []string{"youtube-dl", "yt-dlp"} {
+		if p, err := exec.LookPath(n); err == nil {
+			return p
+		}
+	}
+
+	return "youtube-dl"
+}
 
 // Printer is something that can print
 type Printer interface {
@@ -115,12 +128,13 @@ type Info struct {
 	WebpageURL  string `json:"webpage_url"`
 	Description string `json:"description"`
 	Thumbnail   string `json:"thumbnail"`
-	// not unmarshalled, populated from image thumbnail file
+	// don't unmarshal, populated from image thumbnail file
 	ThumbnailBytes []byte      `json:"-"`
 	Thumbnails     []Thumbnail `json:"thumbnails"`
 
 	Formats           []Format              `json:"formats"`
 	Subtitles         map[string][]Subtitle `json:"subtitles"`
+	AutomaticCaptions map[string][]*Caption `json:"automatic_captions"`
 
 	// Playlist entries if _type is playlist
 	Entries []Info `json:"entries"`
@@ -166,7 +180,15 @@ type Subtitle struct {
 	URL      string `json:"url"`
 	Ext      string `json:"ext"`
 	Language string `json:"-"`
-	// not unmarshalled, populated from subtitle file
+	// don't unmarshal, populated from subtitle file
+	Bytes []byte `json:"-"`
+}
+
+type Caption struct {
+	Ext      string `json:"ext"`
+	Protocol string `json:"protocol"`
+	URL      string `json:"url"`
+	Name     string `json:"name"`
 	Bytes    []byte `json:"-"`
 }
 
@@ -191,12 +213,15 @@ const (
 	TypeSingle
 	// TypePlaylist playlist with multiple tracks, files etc
 	TypePlaylist
+	// TypeChannel channel containing one or more playlists, which will be flattened
+	TypeChannel
 )
 
 var TypeFromString = map[string]Type{
 	"any":      TypeAny,
 	"single":   TypeSingle,
 	"playlist": TypePlaylist,
+	"channel":  TypeChannel,
 }
 
 // Options for New()
@@ -204,17 +229,36 @@ type Options struct {
 	Type                    Type
 	PlaylistStart           uint   // --playlist-start
 	PlaylistEnd             uint   // --playlist-end
+	Downloader              string // --downloader
 	DownloadThumbnail       bool
 	DownloadSubtitles       bool
+	DownloadSubtitlesLang   []string
+	DownloadSubtitlesFormat string
+	DownloadSections        string // --download-sections
+	Impersonate             string // --impersonate
+
+	ProxyUrl           string // --proxy URL  http://host:port or socks5://host:port
+	UseIPV4            bool   // -4 Make all connections via IPv4
+	Cookies            string // --cookies FILE
+	CookiesFromBrowser string // --cookies-from-browser BROWSER[:FOLDER]
 	DebugLog           Printer
 	StderrFn           func(cmd *exec.Cmd) io.Writer // if not nil, function to get Writer for stderr
 	HTTPClient         *http.Client                  // Client for download thumbnail and subtitles (nil use http.DefaultClient)
+	MergeOutputFormat  string                        // --merge-output-format
+	SortingFormat      string                        // --format-sort
+	ExtractorArgs      string                        // --extractor-args
+	InfoArgs           []string
+	DownloadArgs       []string
+
+	// Set to true if you don't want to use the result.Info structure after the goutubedl.New() call,
+	// so the given URL will be downloaded in a single pass in the DownloadResult.Download() call.
+	noInfoDownload bool
 }
 
 // Version of youtube-dl.
 // Might be a good idea to call at start to assert that youtube-dl can be found.
 func Version(ctx context.Context) (string, error) {
-	cmd := exec.CommandContext(ctx, Path, "--version")
+	cmd := exec.CommandContext(ctx, ProbePath(), "--version")
 	versionBytes, cmdErr := cmd.Output()
 	if cmdErr != nil {
 		return "", cmdErr
@@ -223,12 +267,35 @@ func Version(ctx context.Context) (string, error) {
 	return strings.TrimSpace(string(versionBytes)), nil
 }
 
+// Downloads given URL using the given options and filter (usually a format id or quality designator).
+// If filter is empty, then youtube-dl will use its default format selector.
+func Download(
+	ctx context.Context,
+	rawURL string,
+	options Options,
+	filter string,
+) (*DownloadResult, error) {
+	options.noInfoDownload = true
+	d, err := New(ctx, rawURL, options)
+	if err != nil {
+		return nil, err
+	}
+	return d.Download(ctx, filter)
+}
+
 // New downloads metadata for URL
 func New(ctx context.Context, rawURL string, options Options) (result Result, err error) {
 	if options.DebugLog == nil {
 		options.DebugLog = nopPrinter{}
 	}
 
+	if options.noInfoDownload {
+		return Result{
+			RawURL:  rawURL,
+			Options: options,
+		}, nil
+	}
+
 	info, rawJSON, err := infoFromURL(ctx, rawURL, options)
 	if err != nil {
 		return Result{}, err
@@ -239,26 +306,69 @@ func New(ctx context.Context, rawURL string, options Options) (result Result, er
 
 	return Result{
 		Info:    info,
+		RawURL:  rawURL,
 		RawJSON: rawJSONCopy,
 		Options: options,
 	}, nil
 }
 
-func infoFromURL(ctx context.Context, rawURL string, options Options) (info Info, rawJSON []byte, err error) {
+func infoFromURL(
+	ctx context.Context,
+	rawURL string,
+	options Options,
+) (info Info, rawJSON []byte, err error) {
 	cmd := exec.CommandContext(
 		ctx,
-		Path,
+		ProbePath(),
 		// see comment below about ignoring errors for playlists
 		"--ignore-errors",
+		// TODO: deprecated in yt-dlp?
 		"--no-call-home",
-		"--no-cache-dir",
-		"--skip-download",
+		// use safer output filenmaes
+		// TODO: needed?
 		"--restrict-filenames",
-		// provide URL via stdin for security, youtube-dl has some run command args
+		// use .netrc authentication data
+		"--netrc",
+		// provide url via stdin for security, youtube-dl has some run command args
 		"--batch-file", "-",
-		"-J",
+		// dump info json
+		"--dump-single-json",
 	)
-	if options.Type == TypePlaylist {
+
+	if options.ProxyUrl != "" {
+		cmd.Args = append(cmd.Args, "--proxy", options.ProxyUrl)
+	}
+
+	if options.UseIPV4 {
+		cmd.Args = append(cmd.Args, "-4")
+	}
+
+	if options.Downloader != "" {
+		cmd.Args = append(cmd.Args, "--downloader", options.Downloader)
+	}
+
+	if options.Impersonate != "" {
+		cmd.Args = append(cmd.Args, "--impersonate", options.Impersonate)
+	}
+
+	if options.Cookies != "" {
+		cmd.Args = append(cmd.Args, "--cookies", options.Cookies)
+	}
+
+	if options.CookiesFromBrowser != "" {
+		cmd.Args = append(cmd.Args, "--cookies-from-browser", options.CookiesFromBrowser)
+	}
+
+	if options.ExtractorArgs != "" {
+		cmd.Args = append(cmd.Args,
+			"--extractor-args", options.ExtractorArgs,
+		)
+	}
+
+	cmd.Args = append(cmd.Args, options.InfoArgs...)
+
+	switch options.Type {
+	case TypePlaylist, TypeChannel:
 		cmd.Args = append(cmd.Args, "--yes-playlist")
 
 		if options.PlaylistStart > 0 {
@@ -271,7 +381,7 @@ func infoFromURL(ctx context.Context, rawURL string, options Options) (info Info
 				"--playlist-end", strconv.Itoa(int(options.PlaylistEnd)),
 			)
 		}
-	} else {
+	case TypeSingle:
 		if options.DownloadSubtitles {
 			cmd.Args = append(cmd.Args,
 				"--all-subs",
@@ -280,14 +390,18 @@ func infoFromURL(ctx context.Context, rawURL string, options Options) (info Info
 		cmd.Args = append(cmd.Args,
 			"--no-playlist",
 		)
+	case TypeAny:
+		break
+	default:
+		return Info{}, nil, fmt.Errorf("unhandled options type value: %d", options.Type)
 	}
 
-	tempPath, _ := ioutil.TempDir("", "ydls")
+	tempPath, _ := os.MkdirTemp("", "ydls")
 	defer os.RemoveAll(tempPath)
 
 	stdoutBuf := &bytes.Buffer{}
 	stderrBuf := &bytes.Buffer{}
-	stderrWriter := ioutil.Discard
+	stderrWriter := io.Discard
 	if options.StderrFn != nil {
 		stderrWriter = options.StderrFn(cmd)
 	}
@@ -361,7 +475,7 @@ func infoFromURL(ctx context.Context, rawURL string, options Options) (info Info
 	if options.DownloadThumbnail && info.Thumbnail != "" {
 		resp, respErr := get(info.Thumbnail)
 		if respErr == nil {
-			buf, _ := ioutil.ReadAll(resp.Body)
+			buf, _ := io.ReadAll(resp.Body)
 			resp.Body.Close()
 			info.ThumbnailBytes = buf
 		}
@@ -373,12 +487,37 @@ func infoFromURL(ctx context.Context, rawURL string, options Options) (info Info
 		}
 	}
 
+	for _, lang := range options.DownloadSubtitlesLang {
+		if _, ok := info.AutomaticCaptions[lang]; !ok {
+			continue
+		}
+
+		for _, caption := range info.AutomaticCaptions[lang] {
+			if options.DownloadSubtitlesFormat != "" && caption.Ext != options.DownloadSubtitlesFormat {
+				continue
+			}
+
+			resp, respErr := get(caption.URL)
+			if respErr == nil {
+				buf, err := io.ReadAll(resp.Body)
+				if err != nil {
+					options.DebugLog.Print("err", "download captions "+caption.URL, err)
+				}
+				resp.Body.Close()
+				caption.Bytes = buf
+			} else {
+				options.DebugLog.Print("err", "download captions "+caption.URL, respErr)
+			}
+		}
+
+	}
+
 	if options.DownloadSubtitles {
 		for _, subtitles := range info.Subtitles {
 			for i, subtitle := range subtitles {
 				resp, respErr := get(subtitle.URL)
 				if respErr == nil {
-					buf, _ := ioutil.ReadAll(resp.Body)
+					buf, _ := io.ReadAll(resp.Body)
 					resp.Body.Close()
 					subtitles[i].Bytes = buf
 				}
@@ -387,15 +526,31 @@ func infoFromURL(ctx context.Context, rawURL string, options Options) (info Info
 	}
 
 	// as we ignore errors for playlists some entries might show up as null
-	if options.Type == TypePlaylist {
-		var filteredEntrise []Info
+	//
+	// note: instead of doing full recursion, we assume entries in
+	// playlists and channels are at most 2 levels deep, and we just
+	// collect entries from both levels.
+	//
+	// the following cases have not been tested:
+	//
+	// - entries that are more than 2 levels deep (will be missed)
+	// - the ability to restrict entries to a single level (we include both levels)
+	if options.Type == TypePlaylist || options.Type == TypeChannel {
+		var filteredEntries []Info
 		for _, e := range info.Entries {
-			if e.ID == "" {
+			if e.Type == "playlist" {
+				for _, ee := range e.Entries {
+					if ee.ID == "" {
 						continue
 					}
-			filteredEntrise = append(filteredEntrise, e)
+					filteredEntries = append(filteredEntries, ee)
 				}
-		info.Entries = filteredEntrise
+				continue
+			} else if e.ID != "" {
+				filteredEntries = append(filteredEntries, e)
+			}
+		}
+		info.Entries = filteredEntries
 	}
 
 	return info, stdoutBuf.Bytes(), nil
@@ -404,6 +559,7 @@ func infoFromURL(ctx context.Context, rawURL string, options Options) (info Info
 // Result metadata for a URL
 type Result struct {
 	Info    Info
+	RawURL  string
 	RawJSON []byte  // saved raw JSON. Used later when downloading
 	Options Options // options passed to New
 }
@@ -414,25 +570,56 @@ type DownloadResult struct {
 	waitCh chan struct{}
 }
 
-// Download format matched by filter (usually a format id or "best").
-// Filter should not be a combine filter like "1+2" as then youtube-dl
-// won't write to stdout.
+// Download format matched by filter (usually a format id or quality designator).
+// If filter is empty, then youtube-dl will use its default format selector.
+// It's a shortcut of DownloadWithOptions where the options use the default value
 func (result Result) Download(ctx context.Context, filter string) (*DownloadResult, error) {
+	return result.DownloadWithOptions(ctx, DownloadOptions{
+		Filter: filter,
+	})
+}
+
+type DownloadOptions struct {
+	AudioFormats      string // --audio-formats Download audio using formats (best, aac, alac, flac, m4a, mp3, opus, vorbis, wav)
+	DownloadAudioOnly bool   // -x Download audio only from video
+	// Download format matched by filter (usually a format id or quality designator).
+	// If filter is empty, then youtube-dl will use its default format selector.
+	Filter string
+	// The index of the entry to download from the playlist that would be
+	// passed to youtube-dl via --playlist-items. The index value starts at 1
+	PlaylistIndex int
+}
+
+func (result Result) DownloadWithOptions(
+	ctx context.Context,
+	options DownloadOptions,
+) (*DownloadResult, error) {
 	debugLog := result.Options.DebugLog
 
-	if result.Info.Type == "playlist" || result.Info.Type == "multi_video" {
-		return nil, fmt.Errorf("can't download a playlist")
+	if !result.Options.noInfoDownload {
+		if (result.Info.Type == "playlist" ||
+			result.Info.Type == "multi_video" ||
+			result.Info.Type == "channel") &&
+			options.PlaylistIndex == 0 {
+			return nil, fmt.Errorf(
+				"can't download a playlist when the playlist index options is not set",
+			)
+		}
 	}
 
-	tempPath, tempErr := ioutil.TempDir("", "ydls")
+	tempPath, tempErr := os.MkdirTemp("", "ydls")
 	if tempErr != nil {
 		return nil, tempErr
 	}
-	jsonTempPath := path.Join(tempPath, "info.json")
-	if err := ioutil.WriteFile(jsonTempPath, result.RawJSON, 0600); err != nil {
+
+	var jsonTempPath string
+	if !result.Options.noInfoDownload {
+		jsonTempPath = path.Join(tempPath, "info.json")
+		if err := os.WriteFile(jsonTempPath, result.RawJSON, 0600); err != nil {
 			os.RemoveAll(tempPath)
 			return nil, err
 		}
+	}
 
 	dr := &DownloadResult{
 		waitCh: make(chan struct{}),
@@ -440,31 +627,118 @@ func (result Result) Download(ctx context.Context, filter string) (*DownloadResu
 
 	cmd := exec.CommandContext(
 		ctx,
-		Path,
-		"--no-call-home",
-		"--no-cache-dir",
+		ProbePath(),
+		// see comment below about ignoring errors for playlists
 		"--ignore-errors",
+		// TODO: deprecated in yt-dlp?
+		"--no-call-home",
+		// use non-fancy progress bar
 		"--newline",
+		// use safer output filenmaes
+		// TODO: needed?
 		"--restrict-filenames",
-		"--load-info", jsonTempPath,
-		"-o", "-",
+		// use .netrc authentication data
+		"--netrc",
+		// write to stdout
+		"--output", "-",
 	)
+
+	if result.Options.noInfoDownload {
+		// provide URL via stdin for security, youtube-dl has some run command args
+		cmd.Args = append(cmd.Args, "--batch-file", "-")
+		cmd.Stdin = bytes.NewBufferString(result.RawURL + "\n")
+
+		if result.Options.Type == TypePlaylist {
+			cmd.Args = append(cmd.Args, "--yes-playlist")
+
+			if result.Options.PlaylistStart > 0 {
+				cmd.Args = append(cmd.Args,
+					"--playlist-start", strconv.Itoa(int(result.Options.PlaylistStart)),
+				)
+			}
+			if result.Options.PlaylistEnd > 0 {
+				cmd.Args = append(cmd.Args,
+					"--playlist-end", strconv.Itoa(int(result.Options.PlaylistEnd)),
+				)
+			}
+		} else {
+			cmd.Args = append(cmd.Args,
+				"--no-playlist",
+			)
+		}
+	} else {
+		cmd.Args = append(cmd.Args, "--load-info", jsonTempPath)
+	}
+	// force IPV4 Usage
+	if result.Options.UseIPV4 {
+		cmd.Args = append(cmd.Args, "-4")
+	}
 	// don't need to specify if direct as there is only one
 	// also seems to be issues when using filter with generic extractor
-	if !result.Info.Direct {
-		cmd.Args = append(cmd.Args, "-f", filter)
+	if !result.Info.Direct && options.Filter != "" {
+		cmd.Args = append(cmd.Args, "-f", options.Filter)
 	}
 
+	if options.PlaylistIndex > 0 {
+		cmd.Args = append(cmd.Args, "--playlist-items", fmt.Sprint(options.PlaylistIndex))
+	}
+
+	if options.DownloadAudioOnly {
+		cmd.Args = append(cmd.Args, "-x")
+	}
+
+	if options.AudioFormats != "" {
+		cmd.Args = append(cmd.Args, "--audio-format", options.AudioFormats)
+	}
+
+	if result.Options.ProxyUrl != "" {
+		cmd.Args = append(cmd.Args, "--proxy", result.Options.ProxyUrl)
+	}
+
+	if result.Options.Downloader != "" {
+		cmd.Args = append(cmd.Args, "--downloader", result.Options.Downloader)
+	}
+
+	if result.Options.DownloadSections != "" {
+		cmd.Args = append(cmd.Args, "--download-sections", result.Options.DownloadSections)
+	}
+
+	if result.Options.CookiesFromBrowser != "" {
+		cmd.Args = append(cmd.Args, "--cookies-from-browser", result.Options.CookiesFromBrowser)
+	}
+
+	if result.Options.MergeOutputFormat != "" {
+		cmd.Args = append(cmd.Args,
+			"--merge-output-format", result.Options.MergeOutputFormat,
+		)
+	}
+
+	if result.Options.SortingFormat != "" {
+		cmd.Args = append(cmd.Args,
+			"--format-sort", result.Options.SortingFormat,
+		)
+	}
+
+	if result.Options.ExtractorArgs != "" {
+		cmd.Args = append(cmd.Args,
+			"--extractor-args", result.Options.ExtractorArgs,
+		)
+	}
+
+	cmd.Args = append(cmd.Args, result.Options.DownloadArgs...)
+
 	cmd.Dir = tempPath
-	var w io.WriteCloser
-	dr.reader, w = io.Pipe()
-
-	stderrWriter := ioutil.Discard
+	var stdoutW io.WriteCloser
+	var stderrW io.WriteCloser
+	var stderrR io.Reader
+	dr.reader, stdoutW = io.Pipe()
+	stderrR, stderrW = io.Pipe()
+	optStderrWriter := io.Discard
 	if result.Options.StderrFn != nil {
-		stderrWriter = result.Options.StderrFn(cmd)
+		optStderrWriter = result.Options.StderrFn(cmd)
 	}
-	cmd.Stdout = w
-	cmd.Stderr = stderrWriter
+	cmd.Stdout = stdoutW
+	cmd.Stderr = io.MultiWriter(optStderrWriter, stderrW)
 
 	debugLog.Print("cmd", " ", cmd.Args)
 	if err := cmd.Start(); err != nil {
@@ -473,13 +747,33 @@ func (result Result) Download(ctx context.Context, filter string) (*DownloadResu
 	}
 
 	go func() {
-		cmd.Wait()
-		w.Close()
+		_ = cmd.Wait()
+		stdoutW.Close()
+		stderrW.Close()
 		os.RemoveAll(tempPath)
 		close(dr.waitCh)
 	}()
 
-	return dr, nil
+	// blocks return until yt-dlp is downloading or has errored
+	ytErrCh := make(chan error)
+	go func() {
+		stderrLineScanner := bufio.NewScanner(stderrR)
+		for stderrLineScanner.Scan() {
+			const downloadPrefix = "[download]"
+			const errorPrefix = "ERROR: "
+			line := stderrLineScanner.Text()
+			if strings.HasPrefix(line, downloadPrefix) {
+				break
+			} else if strings.HasPrefix(line, errorPrefix) {
+				ytErrCh <- errors.New(line[len(errorPrefix):])
+				return
+			}
+		}
+		ytErrCh <- nil
+		_, _ = io.Copy(io.Discard, stderrR)
+	}()
+
+	return dr, <-ytErrCh
 }
 
 func (dr *DownloadResult) Read(p []byte) (n int, err error) {

goutubedl_test.go

@@ -1,4 +1,4 @@
-package goutubedl
+package goutubedl_test
 
 // TODO: currently the tests only run on linux as they use osleaktest which only
 // has linux support
@@ -7,19 +7,26 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"fmt"
 	"io"
+	"os"
 	"os/exec"
 	"regexp"
+	"strconv"
 	"strings"
 	"testing"
 
+	"gitea.kaz62.ru/dilap54/goutubedl"
 	"github.com/fortytw2/leaktest"
 	"github.com/wader/osleaktest"
 )
 
-const testVideoRawURL = "https://www.youtube.com/watch?v=C0DPdy98e4c"
-const playlistRawURL = "https://soundcloud.com/mattheis/sets/kindred-phenomena"
-const subtitlesTestVideoRawURL = "https://www.youtube.com/watch?v=QRS8MkLhQmM"
+const (
+	testVideoRawURL          = "https://vimeo.com/454525548"
+	playlistRawURL           = "https://soundcloud.com/mattheis/sets/kindred-phenomena"
+	channelRawURL            = "https://www.youtube.com/channel/UCHDm-DKoMyJxKVgwGmuTaQA"
+	subtitlesTestVideoRawURL = "https://www.youtube.com/watch?v=QRS8MkLhQmM"
+)
 
 func leakChecks(t *testing.T) func() {
 	leakFn := leaktest.Check(t)
@@ -33,10 +40,10 @@ func leakChecks(t *testing.T) func() {
 
 func TestBinaryNotPath(t *testing.T) {
 	defer leakChecks(t)()
-	defer func(orig string) { Path = orig }(Path)
-	Path = "/non-existing"
+	defer func(orig string) { goutubedl.Path = orig }(goutubedl.Path)
+	goutubedl.Path = "/non-existing"
 
-	_, versionErr := Version(context.Background())
+	_, versionErr := goutubedl.Version(context.Background())
 	if versionErr == nil || !strings.Contains(versionErr.Error(), "no such file or directory") {
 		t.Fatalf("err should be nil 'no such file or directory': %v", versionErr)
 	}
@@ -46,7 +53,7 @@ func TestVersion(t *testing.T) {
 	defer leakChecks(t)()
 
 	versionRe := regexp.MustCompile(`^\d{4}\.\d{2}.\d{2}.*$`)
-	version, versionErr := Version(context.Background())
+	version, versionErr := goutubedl.Version(context.Background())
 
 	if versionErr != nil {
 		t.Fatalf("err: %s", versionErr)
@@ -61,7 +68,7 @@ func TestDownload(t *testing.T) {
 	defer leakChecks(t)()
 
 	stderrBuf := &bytes.Buffer{}
-	r, err := New(context.Background(), testVideoRawURL, Options{
+	r, err := goutubedl.New(context.Background(), testVideoRawURL, goutubedl.Options{
 		StderrFn: func(cmd *exec.Cmd) io.Writer {
 			return stderrBuf
 		},
@@ -84,8 +91,40 @@ func TestDownload(t *testing.T) {
 		t.Errorf("copy n not equal to download buffer: %d!=%d", n, downloadBuf.Len())
 	}
 
-	if n < 29000 {
-		t.Errorf("should have copied at least 29000 bytes: %d", n)
+	if n < 10000 {
+		t.Errorf("should have copied at least 10000 bytes: %d", n)
+	}
+
+	if !strings.Contains(stderrBuf.String(), "Destination") {
+		t.Errorf("did not find expected log message on stderr: %q", stderrBuf.String())
+	}
+}
+
+func TestDownloadWithoutInfo(t *testing.T) {
+	defer leakChecks(t)()
+
+	stderrBuf := &bytes.Buffer{}
+	dr, err := goutubedl.Download(context.Background(), testVideoRawURL, goutubedl.Options{
+		StderrFn: func(cmd *exec.Cmd) io.Writer {
+			return stderrBuf
+		},
+	}, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	downloadBuf := &bytes.Buffer{}
+	n, err := io.Copy(downloadBuf, dr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dr.Close()
+
+	if n != int64(downloadBuf.Len()) {
+		t.Errorf("copy n not equal to download buffer: %d!=%d", n, downloadBuf.Len())
+	}
+
+	if n < 10000 {
+		t.Errorf("should have copied at least 10000 bytes: %d", n)
 	}
 
 	if !strings.Contains(stderrBuf.String(), "Destination") {
@@ -99,14 +138,14 @@ func TestParseInfo(t *testing.T) {
 		expectedTitle string
 	}{
 		{"https://soundcloud.com/avalonemerson/avalon-emerson-live-at-printworks-london-march-2017", "Avalon Emerson Live at Printworks London 2017"},
-		{"https://www.infoq.com/presentations/Simple-Made-Easy", "Simple Made Easy"},
-		{"https://www.youtube.com/watch?v=uVYWQJ5BB_w", "A Radiolab Producer on the Making of a Podcast"},
+		{"https://www.infoq.com/presentations/Simple-Made-Easy", "Simple Made Easy - InfoQ"},
+		{"https://vimeo.com/454525548", "Sample Video - 3 minutemp4.mp4"},
 	} {
 		t.Run(c.url, func(t *testing.T) {
 			defer leakChecks(t)()
 
 			ctx, cancelFn := context.WithCancel(context.Background())
-			ydlResult, err := New(ctx, c.url, Options{
+			ydlResult, err := goutubedl.New(ctx, c.url, goutubedl.Options{
 				DownloadThumbnail: true,
 			})
 			if err != nil {
@@ -156,8 +195,8 @@ func TestParseInfo(t *testing.T) {
 func TestPlaylist(t *testing.T) {
 	defer leakChecks(t)()
 
-	ydlResult, ydlResultErr := New(context.Background(), playlistRawURL, Options{
-		Type:              TypePlaylist,
+	ydlResult, ydlResultErr := goutubedl.New(context.Background(), playlistRawURL, goutubedl.Options{
+		Type:              goutubedl.TypePlaylist,
 		DownloadThumbnail: false,
 	})
 
@@ -181,14 +220,48 @@ func TestPlaylist(t *testing.T) {
 	}
 }
 
-func TestTestUnsupportedURL(t *testing.T) {
+func TestChannel(t *testing.T) {
+	t.Skip("skip youtube for now")
+
+	defer leakChecks(t)()
+
+	ydlResult, ydlResultErr := goutubedl.New(
+		context.Background(),
+		channelRawURL,
+		goutubedl.Options{
+			Type:              goutubedl.TypeChannel,
+			DownloadThumbnail: false,
+		},
+	)
+
+	if ydlResultErr != nil {
+		t.Errorf("failed to download: %s", ydlResultErr)
+	}
+
+	expectedTitle := "Simon Yapp"
+	if ydlResult.Info.Title != expectedTitle {
+		t.Errorf("expected title %q got %q", expectedTitle, ydlResult.Info.Title)
+	}
+
+	expectedEntries := 5
+	if len(ydlResult.Info.Entries) != expectedEntries {
+		t.Errorf("expected %d entries got %d", expectedEntries, len(ydlResult.Info.Entries))
+	}
+
+	expectedTitleOne := "#RNLI Shoreham #LifeBoat demo of launch."
+	if ydlResult.Info.Entries[0].Title != expectedTitleOne {
+		t.Errorf("expected title %q got %q", expectedTitleOne, ydlResult.Info.Entries[0].Title)
+	}
+}
+
+func TestUnsupportedURL(t *testing.T) {
 	defer leaktest.Check(t)()
 
-	_, ydlResultErr := New(context.Background(), "https://www.google.com", Options{})
+	_, ydlResultErr := goutubedl.New(context.Background(), "https://www.google.com", goutubedl.Options{})
 	if ydlResultErr == nil {
 		t.Errorf("expected unsupported url")
 	}
-	expectedErrPrefix := "Unsupported URL: https://www.google.com"
+	expectedErrPrefix := "Unsupported URL:"
 	if ydlResultErr != nil && !strings.HasPrefix(ydlResultErr.Error(), expectedErrPrefix) {
 		t.Errorf("expected error prefix %q got %q", expectedErrPrefix, ydlResultErr.Error())
 
@@ -196,11 +269,13 @@ func TestTestUnsupportedURL(t *testing.T) {
 }
 
 func TestPlaylistWithPrivateVideo(t *testing.T) {
+	t.Skip("skip youtube for now")
+
 	defer leaktest.Check(t)()
 
 	playlistRawURL := "https://www.youtube.com/playlist?list=PLX0g748fkegS54oiDN4AXKl7BR7mLIydP"
-	ydlResult, ydlResultErr := New(context.Background(), playlistRawURL, Options{
-		Type:              TypePlaylist,
+	ydlResult, ydlResultErr := goutubedl.New(context.Background(), playlistRawURL, goutubedl.Options{
+		Type:              goutubedl.TypePlaylist,
 		DownloadThumbnail: false,
 	})
 
@@ -216,12 +291,14 @@ func TestPlaylistWithPrivateVideo(t *testing.T) {
 }
 
 func TestSubtitles(t *testing.T) {
+	t.Skip("skip youtube for now")
+
 	defer leakChecks(t)()
 
-	ydlResult, ydlResultErr := New(
+	ydlResult, ydlResultErr := goutubedl.New(
 		context.Background(),
 		subtitlesTestVideoRawURL,
-		Options{
+		goutubedl.Options{
 			DownloadSubtitles: true,
 		})
 
@@ -247,14 +324,81 @@ func TestSubtitles(t *testing.T) {
 	}
 }
 
+func TestDownloadSections(t *testing.T) {
+	defer leakChecks(t)()
+
+	fileName := "durationTestingFile"
+	duration := 5
+
+	cmd := exec.Command("ffmpeg", "-version")
+	_, err := cmd.Output()
+	if err != nil {
+		t.Errorf("failed to check ffmpeg installed: %s", err)
+	}
+
+	ydlResult, ydlResultErr := goutubedl.New(
+		context.Background(),
+		"https://vimeo.com/454525548",
+		goutubedl.Options{
+			DownloadSections: fmt.Sprintf("*0:0-0:%d", duration),
+		})
+
+	if ydlResult.Options.DownloadSections != "*0:0-0:5" {
+		t.Errorf("failed to setup --download-sections")
+	}
+	if ydlResultErr != nil {
+		t.Errorf("failed to download: %s", ydlResultErr)
+	}
+	dr, err := ydlResult.Download(context.Background(), "")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	f, err := os.Create(fileName)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	_, err = io.Copy(f, dr)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	cmd = exec.Command("ffprobe", "-v", "quiet", "-show_entries", "format=duration", fileName)
+	stdout, err := cmd.Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var gotDurationString string
+	output := string(stdout)
+	for _, line := range strings.Split(output, "\n") {
+		if strings.Contains(line, "duration") {
+			if d, found := strings.CutPrefix(line, "duration="); found {
+				gotDurationString = d
+			}
+		}
+	}
+
+	gotDuration, err := strconv.ParseFloat(gotDurationString, 32)
+	if err != nil {
+		t.Fatal(err)
+	}
+	seconds := int(gotDuration)
+	if seconds != duration {
+		t.Fatalf("did not get expected duration of %d, but got %d", duration, seconds)
+	}
+	dr.Close()
+}
+
 func TestErrorNotAPlaylist(t *testing.T) {
 	defer leakChecks(t)()
 
-	_, ydlResultErr := New(context.Background(), testVideoRawURL, Options{
-		Type:              TypePlaylist,
+	_, ydlResultErr := goutubedl.New(context.Background(), testVideoRawURL, goutubedl.Options{
+		Type:              goutubedl.TypePlaylist,
 		DownloadThumbnail: false,
 	})
-	if ydlResultErr != ErrNotAPlaylist {
+	if ydlResultErr != goutubedl.ErrNotAPlaylist {
 		t.Errorf("expected is playlist error, got %s", ydlResultErr)
 	}
 }
@@ -262,11 +406,183 @@ func TestErrorNotAPlaylist(t *testing.T) {
 func TestErrorNotASingleEntry(t *testing.T) {
 	defer leakChecks(t)()
 
-	_, ydlResultErr := New(context.Background(), playlistRawURL, Options{
-		Type:              TypeSingle,
+	_, ydlResultErr := goutubedl.New(context.Background(), playlistRawURL, goutubedl.Options{
+		Type:              goutubedl.TypeSingle,
 		DownloadThumbnail: false,
 	})
-	if ydlResultErr != ErrNotASingleEntry {
-		t.Errorf("expected is single entry error, got %s", ydlResultErr)
+	if ydlResultErr != goutubedl.ErrNotASingleEntry {
+		t.Fatalf("expected is single entry error, got %s", ydlResultErr)
+	}
+}
+
+func TestOptionDownloader(t *testing.T) {
+	defer leakChecks(t)()
+
+	ydlResult, ydlResultErr := goutubedl.New(
+		context.Background(),
+		testVideoRawURL,
+		goutubedl.Options{
+			Downloader: "ffmpeg",
+		})
+
+	if ydlResultErr != nil {
+		t.Fatalf("failed to download: %s", ydlResultErr)
+	}
+	dr, err := ydlResult.Download(context.Background(), ydlResult.Info.Formats[0].FormatID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	downloadBuf := &bytes.Buffer{}
+	_, err = io.Copy(downloadBuf, dr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dr.Close()
+}
+
+func TestInvalidOptionTypeField(t *testing.T) {
+	defer leakChecks(t)()
+
+	_, err := goutubedl.New(context.Background(), playlistRawURL, goutubedl.Options{
+		Type: 42,
+	})
+	if err == nil {
+		t.Error("should have failed")
+	}
+}
+
+func TestDownloadPlaylistEntry(t *testing.T) {
+	defer leakChecks(t)()
+	// Download file by specifying the playlist index
+	stderrBuf := &bytes.Buffer{}
+	r, err := goutubedl.New(context.Background(), playlistRawURL, goutubedl.Options{
+		StderrFn: func(cmd *exec.Cmd) io.Writer {
+			return stderrBuf
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expectedTitle := "Kindred Phenomena"
+	if r.Info.Title != expectedTitle {
+		t.Errorf("expected title %q got %q", expectedTitle, r.Info.Title)
+	}
+
+	expectedEntries := 8
+	if len(r.Info.Entries) != expectedEntries {
+		t.Errorf("expected %d entries got %d", expectedEntries, len(r.Info.Entries))
+	}
+
+	expectedTitleOne := "B1 Mattheis - Ben M"
+	playlistIndex := 2
+	if r.Info.Entries[playlistIndex].Title != expectedTitleOne {
+		t.Errorf("expected title %q got %q", expectedTitleOne, r.Info.Entries[playlistIndex].Title)
+	}
+
+	dr, err := r.DownloadWithOptions(context.Background(), goutubedl.DownloadOptions{
+		PlaylistIndex: int(r.Info.Entries[playlistIndex].PlaylistIndex),
+		Filter:        r.Info.Entries[playlistIndex].Formats[0].FormatID,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	playlistBuf := &bytes.Buffer{}
+	n, err := io.Copy(playlistBuf, dr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dr.Close()
+
+	if n != int64(playlistBuf.Len()) {
+		t.Errorf("copy n not equal to download buffer: %d!=%d", n, playlistBuf.Len())
+	}
+
+	if n < 10000 {
+		t.Errorf("should have copied at least 10000 bytes: %d", n)
+	}
+
+	if !strings.Contains(stderrBuf.String(), "Destination") {
+		t.Errorf("did not find expected log message on stderr: %q", stderrBuf.String())
+	}
+
+	// Download the same file but with the direct link
+	url := "https://soundcloud.com/mattheis/b1-mattheis-ben-m"
+	stderrBuf = &bytes.Buffer{}
+	r, err = goutubedl.New(context.Background(), url, goutubedl.Options{
+		StderrFn: func(cmd *exec.Cmd) io.Writer {
+			return stderrBuf
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if r.Info.Title != expectedTitleOne {
+		t.Errorf("expected title %q got %q", expectedTitleOne, r.Info.Title)
+	}
+
+	expectedEntries = 0
+	if len(r.Info.Entries) != expectedEntries {
+		t.Errorf("expected %d entries got %d", expectedEntries, len(r.Info.Entries))
+	}
+
+	dr, err = r.Download(context.Background(), r.Info.Formats[0].FormatID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	directLinkBuf := &bytes.Buffer{}
+	n, err = io.Copy(directLinkBuf, dr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dr.Close()
+
+	if n != int64(directLinkBuf.Len()) {
+		t.Errorf("copy n not equal to download buffer: %d!=%d", n, directLinkBuf.Len())
+	}
+
+	if n < 10000 {
+		t.Errorf("should have copied at least 10000 bytes: %d", n)
+	}
+
+	if !strings.Contains(stderrBuf.String(), "Destination") {
+		t.Errorf("did not find expected log message on stderr: %q", stderrBuf.String())
+	}
+
+	if directLinkBuf.Len() != playlistBuf.Len() {
+		t.Errorf("not the same content size between the playlist index entry and the direct link entry: %d != %d", playlistBuf.Len(), directLinkBuf.Len())
+	}
+
+	if !bytes.Equal(directLinkBuf.Bytes(), playlistBuf.Bytes()) {
+		t.Error("not the same content between the playlist index entry and the direct link entry")
+	}
+}
+
+func TestFormatDownloadError(t *testing.T) {
+	t.Skip("test URL broken")
+
+	defer leaktest.Check(t)()
+
+	ydl, ydlErr := goutubedl.New(
+		context.Background(),
+		"https://www.reddit.com/r/newsbabes/s/92rflI0EB0",
+		goutubedl.Options{},
+	)
+
+	if ydlErr != nil {
+		// reddit seems to not like github action hosts
+		if strings.Contains(ydlErr.Error(), "HTTPError 403: Blocked") {
+			t.Skip()
+		}
+		t.Error(ydlErr)
+	}
+
+	// no pre-muxed audio/video format available
+	_, ytDlErr := ydl.Download(context.Background(), "best")
+	expectedErr := "Requested format is not available"
+	if ydlErr != nil && !strings.Contains(ytDlErr.Error(), expectedErr) {
+		t.Errorf("expected error prefix %q got %q", expectedErr, ytDlErr.Error())
+
 	}
 }