diff --git a/.golangci.yml b/.golangci.yml
new file mode 100644
index 000000000..856e932cb
--- /dev/null
+++ b/.golangci.yml
@@ -0,0 +1,24 @@
+run:
+  concurrency: 2
+  timeout: 5m
+
+linter-settings:
+  goconst:
+    min-len: 2
+    min-occurrences: 2
+
+linters:
+  enable:
+    - golint
+    - goconst
+    - gofmt
+    - goimports
+    - misspell
+    - unparam
+
+issues:
+  exclude-use-default: false
+  exclude-rules:
+    - path: _test.go
+      linters:
+        - errcheck
diff --git a/.travis.yml b/.travis.yml
index 11aa9f3d4..24d13c182 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -6,7 +6,11 @@ language: go
 go:
   - "1.13.x"
 
+before_install:
+  - curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh -s -- -b $(go env GOPATH)/bin v1.24.0
+
 script:
+  - golangci-lint run
   - ./go.test.sh
 
 after_success:
diff --git a/config/config.go b/config/config.go
index 9522db9c2..61e3d82b0 100644
--- a/config/config.go
+++ b/config/config.go
@@ -1,62 +1,5 @@
 package config
 
-var (
-	// Debug debug mode
-	Debug bool
-	// Version show version
-	Version bool
-	// InfoOnly Information only mode
-	InfoOnly bool
-	// Cookie http cookies
-	Cookie string
-	// Playlist download playlist
-	Playlist bool
-	// Refer use specified Referrer
-	Refer string
-	// Stream select specified stream to download
-	Stream string
-	// OutputPath output file path
-	OutputPath string
-	// OutputName output file name
-	OutputName string
-	// ExtractedData print extracted data
-	ExtractedData bool
-	// ChunkSizeMB HTTP chunk size for downloading (in MB)
-	ChunkSizeMB int
-	// UseAria2RPC Use Aria2 RPC to download
-	UseAria2RPC bool
-	// Aria2Token Aria2 RPC Token
-	Aria2Token string
-	// Aria2Addr Aria2 Address (default "localhost:6800")
-	Aria2Addr string
-	// Aria2Method Aria2 Method (default "http")
-	Aria2Method string
-	// ThreadNumber The number of download thread (only works for multiple-parts video)
-	ThreadNumber int
-	// File URLs file path
-	File string
-	// ItemStart Define the starting item of a playlist or a file input
-	ItemStart int
-	// ItemEnd Define the ending item of a playlist or a file input
-	ItemEnd int
-	// Items Define wanted items from a file or playlist. Separated by commas like: 1,5,6,8-10
-	Items string
-	// File name of each bilibili episode doesn't include the playlist title
-	EpisodeTitleOnly bool
-	// Caption download captions
-	Caption bool
-	// YoukuCcode youku ccode
-	YoukuCcode string
-	// YoukuCkey youku ckey
-	YoukuCkey string
-	// YoukuPassword youku password
-	YoukuPassword string
-	// RetryTimes how many times to retry when the download failed
-	RetryTimes int
-
-	MultiThread bool
-)
-
 // FakeHeaders fake http headers
 var FakeHeaders = map[string]string{
 	"Accept":          "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
diff --git a/downloader/downloader.go b/downloader/downloader.go
index 383274fb6..6bc2a49f0 100644
--- a/downloader/downloader.go
+++ b/downloader/downloader.go
@@ -17,11 +17,38 @@ import (
 
 	"github.com/cheggaaa/pb"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
 
+// Options defines options used in downloading.
+type Options struct {
+	InfoOnly       bool
+	Stream         string
+	Refer          string
+	OutputPath     string
+	OutputName     string
+	FileNameLength int
+	Caption        bool
+
+	MultiThread  bool
+	ThreadNumber int
+	RetryTimes   int
+	ChunkSizeMB  int
+	// Aria2
+	UseAria2RPC bool
+	Aria2Token  string
+	Aria2Method string
+	Aria2Addr   string
+}
+
+// Downloader is the default downloader.
+type Downloader struct {
+	bar    *pb.ProgressBar
+	option Options
+}
+
 func progressBar(size int64) *pb.ProgressBar {
 	bar := pb.New64(size).SetUnits(pb.U_BYTES).SetRefreshRate(time.Millisecond * 10)
 	bar.ShowSpeed = true
@@ -30,17 +57,27 @@ func progressBar(size int64) *pb.ProgressBar {
 	return bar
 }
 
-// Caption download danmaku, subtitles, etc
-func Caption(url, refer, fileName, ext string) error {
-	if !config.Caption || config.InfoOnly {
-		return nil
+// New returns a new Downloader implementation.
+func New(option Options) *Downloader {
+	downloader := &Downloader{
+		option: option,
 	}
+	return downloader
+}
+
+// caption downloads danmaku, subtitles, etc
+func (downloader *Downloader) caption(url, fileName, ext string) error {
 	fmt.Println("\nDownloading captions...")
+
+	refer := downloader.option.Refer
+	if refer == "" {
+		refer = url
+	}
 	body, err := request.GetByte(url, refer, nil)
 	if err != nil {
 		return err
 	}
-	filePath, err := utils.FilePath(fileName, ext, true)
+	filePath, err := utils.FilePath(fileName, ext, downloader.option.FileNameLength, downloader.option.OutputPath, true)
 	if err != nil {
 		return err
 	}
@@ -48,7 +85,7 @@ func Caption(url, refer, fileName, ext string) error {
 	if fileError != nil {
 		return fileError
 	}
-	defer file.Close()
+	defer file.Close() // nolint
 
 	if _, err = file.Write(body); err != nil {
 		return err
@@ -56,16 +93,14 @@ func Caption(url, refer, fileName, ext string) error {
 	return nil
 }
 
-func writeFile(
-	url string, file *os.File, headers map[string]string, bar *pb.ProgressBar,
-) (int64, error) {
+func (downloader *Downloader) writeFile(url string, file *os.File, headers map[string]string) (int64, error) {
 	res, err := request.Request(http.MethodGet, url, nil, headers)
 	if err != nil {
 		return 0, err
 	}
-	defer res.Body.Close()
+	defer res.Body.Close() // nolint
 
-	writer := io.MultiWriter(file, bar)
+	writer := io.MultiWriter(file, downloader.bar)
 	// Note that io.Copy reads 32kb(maximum) from input and writes them to output, then repeats.
 	// So don't worry about memory.
 	written, copyErr := io.Copy(writer, res.Body)
@@ -75,12 +110,8 @@ func writeFile(
 	return written, nil
 }
 
-// Save save url file
-func Save(
-	urlData URL, refer, fileName string, bar *pb.ProgressBar, chunkSizeMB int,
-) error {
-	var err error
-	filePath, err := utils.FilePath(fileName, urlData.Ext, false)
+func (downloader *Downloader) save(part *types.Part, fileName string) error {
+	filePath, err := utils.FilePath(fileName, part.Ext, downloader.option.FileNameLength, downloader.option.OutputPath, false)
 	if err != nil {
 		return err
 	}
@@ -88,24 +119,19 @@ func Save(
 	if err != nil {
 		return err
 	}
-	if bar == nil {
-		bar = progressBar(urlData.Size)
-		bar.Start()
-	}
 	// Skip segment file
 	// TODO: Live video URLs will not return the size
-	if exists && fileSize == urlData.Size {
-		bar.Add64(fileSize)
+	if exists && fileSize == part.Size {
+		downloader.bar.Add64(fileSize)
 		return nil
 	}
+
 	tempFilePath := filePath + ".download"
 	tempFileSize, _, err := utils.FileSize(tempFilePath)
 	if err != nil {
 		return err
 	}
-	headers := map[string]string{
-		"Referer": refer,
-	}
+	headers := make(map[string]string, 1)
 	var (
 		file      *os.File
 		fileError error
@@ -114,7 +140,7 @@ func Save(
 		// range start from 0, 0-1023 means the first 1024 bytes of the file
 		headers["Range"] = fmt.Sprintf("bytes=%d-", tempFileSize)
 		file, fileError = os.OpenFile(tempFilePath, os.O_APPEND|os.O_WRONLY, 0644)
-		bar.Add64(tempFileSize)
+		downloader.bar.Add64(tempFileSize)
 	} else {
 		file, fileError = os.Create(tempFilePath)
 	}
@@ -126,16 +152,16 @@ func Save(
 	defer func() {
 		// must close the file before rename or it will cause
 		// `The process cannot access the file because it is being used by another process.` error.
-		file.Close()
+		file.Close() // nolint
 		if err == nil {
-			os.Rename(tempFilePath, filePath)
+			os.Rename(tempFilePath, filePath) // nolint
 		}
 	}()
 
-	if chunkSizeMB > 0 {
+	if downloader.option.ChunkSizeMB > 0 {
 		var start, end, chunkSize int64
-		chunkSize = int64(chunkSizeMB) * 1024 * 1024
-		remainingSize := urlData.Size
+		chunkSize = int64(downloader.option.ChunkSizeMB) * 1024 * 1024
+		remainingSize := part.Size
 		if tempFileSize > 0 {
 			start = tempFileSize
 			remainingSize -= tempFileSize
@@ -150,10 +176,10 @@ func Save(
 			headers["Range"] = fmt.Sprintf("bytes=%d-%d", start, end)
 			temp := start
 			for i := 0; ; i++ {
-				written, err := writeFile(urlData.URL, file, headers, bar)
+				written, err := downloader.writeFile(part.URL, file, headers)
 				if err == nil {
 					break
-				} else if i+1 >= config.RetryTimes {
+				} else if i+1 >= downloader.option.RetryTimes {
 					return err
 				}
 				temp += written
@@ -165,10 +191,10 @@ func Save(
 	} else {
 		temp := tempFileSize
 		for i := 0; ; i++ {
-			written, err := writeFile(urlData.URL, file, headers, bar)
+			written, err := downloader.writeFile(part.URL, file, headers)
 			if err == nil {
 				break
-			} else if i+1 >= config.RetryTimes {
+			} else if i+1 >= downloader.option.RetryTimes {
 				return err
 			}
 			temp += written
@@ -180,10 +206,8 @@ func Save(
 	return nil
 }
 
-func MultiThreadSave(
-	urlData URL, refer, fileName string, bar *pb.ProgressBar, chunkSizeMB, threadNum int,
-) error {
-	filePath, err := utils.FilePath(fileName, urlData.Ext, false)
+func (downloader *Downloader) multiThreadSave(dataPart *types.Part, fileName string) error {
+	filePath, err := utils.FilePath(fileName, dataPart.Ext, downloader.option.FileNameLength, downloader.option.OutputPath, false)
 	if err != nil {
 		return err
 	}
@@ -191,14 +215,11 @@ func MultiThreadSave(
 	if err != nil {
 		return err
 	}
-	if bar == nil {
-		bar = progressBar(urlData.Size)
-		bar.Start()
-	}
+
 	// Skip segment file
 	// TODO: Live video URLs will not return the size
-	if exists && fileSize == urlData.Size {
-		bar.Add64(fileSize)
+	if exists && fileSize == dataPart.Size {
+		downloader.bar.Add64(fileSize)
 		return nil
 	}
 	tmpFilePath := filePath + ".download"
@@ -207,19 +228,18 @@ func MultiThreadSave(
 		return err
 	}
 	if tmpExists {
-		if tmpFileSize == urlData.Size {
-			bar.Add64(urlData.Size)
+		if tmpFileSize == dataPart.Size {
+			downloader.bar.Add64(dataPart.Size)
 			return os.Rename(tmpFilePath, filePath)
-		} else {
-			err = os.Remove(tmpFilePath)
-			if err != nil {
-				return err
-			}
+		}
+
+		if err = os.Remove(tmpFilePath); err != nil {
+			return err
 		}
 	}
 
 	// Scan all parts
-	parts, err := readDirAllFilePart(filePath, fileName, urlData.Ext)
+	parts, err := readDirAllFilePart(filePath, fileName, dataPart.Ext)
 	if err != nil {
 		return err
 	}
@@ -259,11 +279,11 @@ func MultiThreadSave(
 			}
 			lastEnd = part.End
 		}
-		if lastEnd != urlData.Size-1 {
+		if lastEnd != dataPart.Size-1 {
 			newPart := &FilePartMeta{
 				Index: parts[len(parts)-1].Index + 1,
 				Start: lastEnd + 1,
-				End:   urlData.Size - 1,
+				End:   dataPart.Size - 1,
 				Cur:   lastEnd + 1,
 			}
 			parts = append(parts, newPart)
@@ -272,14 +292,14 @@ func MultiThreadSave(
 	} else {
 		var start, end, partSize int64
 		var i float32
-		partSize = urlData.Size / int64(threadNum)
+		partSize = dataPart.Size / int64(downloader.option.ThreadNumber)
 		i = 0
-		for start < urlData.Size {
+		for start < dataPart.Size {
 			end = start + partSize - 1
-			if end > urlData.Size {
-				end = urlData.Size - 1
-			} else if int(i+1) == threadNum && end < urlData.Size {
-				end = urlData.Size - 1
+			if end > dataPart.Size {
+				end = dataPart.Size - 1
+			} else if int(i+1) == downloader.option.ThreadNumber && end < dataPart.Size {
+				end = dataPart.Size - 1
 			}
 			part := &FilePartMeta{
 				Index: i,
@@ -294,13 +314,13 @@ func MultiThreadSave(
 		}
 	}
 	if savedSize > 0 {
-		bar.Add64(savedSize)
-		if savedSize == urlData.Size {
+		downloader.bar.Add64(savedSize)
+		if savedSize == dataPart.Size {
 			return mergeMultiPart(filePath, parts)
 		}
 	}
 
-	wgp := utils.NewWaitGroupPool(threadNum)
+	wgp := utils.NewWaitGroupPool(downloader.option.ThreadNumber)
 	var errs []error
 	for _, part := range unfinishedPart {
 		wgp.Add()
@@ -311,17 +331,16 @@ func MultiThreadSave(
 				return
 			}
 			defer func() {
-				file.Close()
+				file.Close() // nolint
 				wgp.Done()
 			}()
+
 			var end, chunkSize int64
-			headers := map[string]string{
-				"Referer": refer,
-			}
-			if chunkSizeMB <= 0 {
+			headers := make(map[string]string, 1)
+			if downloader.option.ChunkSizeMB <= 0 {
 				chunkSize = part.End - part.Start + 1
 			} else {
-				chunkSize = int64(chunkSizeMB) * 1024 * 1024
+				chunkSize = int64(downloader.option.ChunkSizeMB) * 1024 * 1024
 			}
 			end = computeEnd(part.Cur, chunkSize, part.End)
 			remainingSize := part.End - part.Cur + 1
@@ -338,11 +357,11 @@ func MultiThreadSave(
 				headers["Range"] = fmt.Sprintf("bytes=%d-%d", part.Cur, end)
 				temp := part.Cur
 				for i := 0; ; i++ {
-					written, err := writeFile(urlData.URL, file, headers, bar)
+					written, err := downloader.writeFile(dataPart.URL, file, headers)
 					if err == nil {
 						remainingSize -= chunkSize
 						break
-					} else if i+1 >= config.RetryTimes {
+					} else if i+1 >= downloader.option.RetryTimes {
 						errs = append(errs, err)
 						return
 					}
@@ -379,7 +398,7 @@ func readDirAllFilePart(filePath, filename, extname string) ([]*FilePartMeta, er
 	if err != nil {
 		return nil, err
 	}
-	defer dir.Close()
+	defer dir.Close() // nolint
 	fns, err := dir.Readdir(0)
 	if err != nil {
 		return nil, err
@@ -408,14 +427,14 @@ func parseFilePartMeta(filepath string, fileSize int64) (*FilePartMeta, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer file.Close()
+	defer file.Close() // nolint
 	var buf [512]byte
 	readSize, err := file.ReadAt(buf[0:size], 0)
 	if err != nil && err != io.EOF {
 		return nil, err
 	}
 	if readSize < size {
-		return nil, fmt.Errorf("The file has been broked, please delete all part files and re-download.\n")
+		return nil, fmt.Errorf("the file has been broked, please delete all part files and re-download")
 	}
 	err = binary.Read(bytes.NewBuffer(buf[:size]), binary.LittleEndian, meta)
 	if err != nil {
@@ -439,8 +458,8 @@ func mergeMultiPart(filepath string, parts []*FilePartMeta) error {
 	var partFiles []*os.File
 	defer func() {
 		for _, f := range partFiles {
-			f.Close()
-			os.Remove(f.Name())
+			f.Close()           // nolint
+			os.Remove(f.Name()) // nolint
 		}
 	}()
 	for _, part := range parts {
@@ -458,88 +477,89 @@ func mergeMultiPart(filepath string, parts []*FilePartMeta) error {
 			return err
 		}
 	}
-	tempFile.Close()
+	tempFile.Close() // nolint
 	err = os.Rename(tempFilePath, filepath)
 	return err
 }
 
+func (downloader *Downloader) aria2(title string, stream *types.Stream) error {
+	rpcData := Aria2RPCData{
+		JSONRPC: "2.0",
+		ID:      "annie", // can be modified
+		Method:  "aria2.addUri",
+	}
+	rpcData.Params[0] = "token:" + downloader.option.Aria2Token
+	var urls []string
+	for _, p := range stream.Parts {
+		urls = append(urls, p.URL)
+	}
+	var inputs Aria2Input
+	inputs.Header = append(inputs.Header, "Referer: "+downloader.option.Refer)
+	for i := range urls {
+		rpcData.Params[1] = urls[i : i+1]
+		inputs.Out = fmt.Sprintf("%s[%d].%s", title, i, stream.Parts[0].Ext)
+		rpcData.Params[2] = &inputs
+		jsonData, err := json.Marshal(rpcData)
+		if err != nil {
+			return err
+		}
+		reqURL := fmt.Sprintf("%s://%s/jsonrpc", downloader.option.Aria2Method, downloader.option.Aria2Addr)
+		req, err := http.NewRequest(http.MethodPost, reqURL, bytes.NewBuffer(jsonData))
+		if err != nil {
+			return err
+		}
+		req.Header.Set("Content-Type", "application/json")
+
+		var client = http.Client{Timeout: 30 * time.Second}
+		res, err := client.Do(req)
+		if err != nil {
+			return err
+		}
+		// The http Client and Transport guarantee that Body is always
+		// non-nil, even on responses without a body or responses with
+		// a zero-length body.
+		res.Body.Close() // nolint
+	}
+	return nil
+}
+
 // Download download urls
-func Download(v Data, refer string, chunkSizeMB int) error {
-	v.genSortedStreams()
-	var (
-		title  string
-		stream string
-	)
-	if config.OutputName == "" {
-		title = utils.FileName(v.Title, "")
-	} else {
-		title = utils.FileName(config.OutputName, "")
+func (downloader *Downloader) Download(data *types.Data) error {
+	sortedStreams := genSortedStreams(data.Streams)
+	if downloader.option.InfoOnly {
+		printInfo(data, sortedStreams)
+		return nil
 	}
-	if config.Stream == "" {
-		stream = v.sortedStreams[0].name
-	} else {
-		stream = config.Stream
+
+	title := downloader.option.OutputName
+	if title == "" {
+		title = data.Title
 	}
-	data, ok := v.Streams[stream]
+	title = utils.FileName(title, "", downloader.option.FileNameLength)
+
+	streamName := downloader.option.Stream
+	if streamName == "" {
+		streamName = sortedStreams[0].ID
+	}
+	stream, ok := data.Streams[streamName]
 	if !ok {
-		return fmt.Errorf("no stream named %s", stream)
+		return fmt.Errorf("no stream named %s", streamName)
 	}
-	v.printInfo(stream) // if InfoOnly, this func will print all streams info
-	if config.InfoOnly {
-		return nil
+
+	printStreamInfo(data, stream)
+
+	// download caption
+	if downloader.option.Caption && data.Caption != nil {
+		downloader.caption(data.Caption.URL, title, data.Caption.Ext) // nolint
 	}
-	// Use aria2 rpc to download
-	if config.UseAria2RPC {
-		rpcData := Aria2RPCData{
-			JSONRPC: "2.0",
-			ID:      "annie", // can be modified
-			Method:  "aria2.addUri",
-		}
-		rpcData.Params[0] = "token:" + config.Aria2Token
-		var urls []string
-		for _, p := range data.URLs {
-			urls = append(urls, p.URL)
-		}
-		var inputs Aria2Input
-		inputs.Header = append(inputs.Header, "Referer: "+refer)
-		for i := range urls {
-			rpcData.Params[1] = urls[i : i+1]
-			inputs.Out = fmt.Sprintf("%s[%d].%s", title, i, data.URLs[0].Ext)
-			rpcData.Params[2] = &inputs
-			jsonData, err := json.Marshal(rpcData)
-			if err != nil {
-				return err
-			}
-			reqURL := fmt.Sprintf("%s://%s/jsonrpc", config.Aria2Method, config.Aria2Addr)
-			req, err := http.NewRequest(http.MethodPost, reqURL, bytes.NewBuffer(jsonData))
-			if err != nil {
-				return err
-			}
-			req.Header.Set("Content-Type", "application/json")
 
-			var client = http.Client{Timeout: 30 * time.Second}
-			res, err := client.Do(req)
-			if err != nil {
-				return err
-			}
-			// The http Client and Transport guarantee that Body is always
-			// non-nil, even on responses without a body or responses with
-			// a zero-length body.
-			res.Body.Close()
-		}
-		return nil
+	// Use aria2 rpc to download
+	if downloader.option.UseAria2RPC {
+		return downloader.aria2(title, stream)
 	}
 
 	// Skip the complete file that has been merged
-	var (
-		mergedFilePath string
-		err            error
-	)
-	if v.Site == "YouTube youtube.com" {
-		mergedFilePath, err = utils.FilePath(title, data.URLs[0].Ext, false)
-	} else {
-		mergedFilePath, err = utils.FilePath(title, "mp4", false)
-	}
+	mergedFilePath, err := utils.FilePath(title, stream.Ext, downloader.option.FileNameLength, downloader.option.OutputPath, false)
 	if err != nil {
 		return err
 	}
@@ -552,67 +572,66 @@ func Download(v Data, refer string, chunkSizeMB int) error {
 		fmt.Printf("%s: file already exists, skipping\n", mergedFilePath)
 		return nil
 	}
-	bar := progressBar(data.Size)
-	bar.Start()
-	if len(data.URLs) == 1 {
+
+	downloader.bar = progressBar(stream.Size)
+	downloader.bar.Start()
+	if len(stream.Parts) == 1 {
 		// only one fragment
 		var err error
-		if config.MultiThread {
-			err = MultiThreadSave(data.URLs[0], refer, title, bar, chunkSizeMB, config.ThreadNumber)
+		if downloader.option.MultiThread {
+			err = downloader.multiThreadSave(stream.Parts[0], title)
 		} else {
-			err = Save(data.URLs[0], refer, title, bar, chunkSizeMB)
+			err = downloader.save(stream.Parts[0], title)
 		}
 
 		if err != nil {
 			return err
 		}
-		bar.Finish()
+		downloader.bar.Finish()
 		return nil
 	}
-	wgp := utils.NewWaitGroupPool(config.ThreadNumber)
+
+	wgp := utils.NewWaitGroupPool(downloader.option.ThreadNumber)
 	// multiple fragments
 	errs := make([]error, 0)
 	lock := sync.Mutex{}
-	parts := make([]string, len(data.URLs))
-	for index, url := range data.URLs {
+	parts := make([]string, len(stream.Parts))
+	for index, part := range stream.Parts {
 		if len(errs) > 0 {
 			break
 		}
 
 		partFileName := fmt.Sprintf("%s[%d]", title, index)
-		partFilePath, err := utils.FilePath(partFileName, url.Ext, false)
+		partFilePath, err := utils.FilePath(partFileName, part.Ext, downloader.option.FileNameLength, downloader.option.OutputPath, false)
 		if err != nil {
 			return err
 		}
 		parts[index] = partFilePath
 
 		wgp.Add()
-		go func(url URL, refer, fileName string, bar *pb.ProgressBar) {
+		go func(part *types.Part, fileName string) {
 			defer wgp.Done()
-			err := Save(url, refer, fileName, bar, chunkSizeMB)
+			err := downloader.save(part, fileName)
 			if err != nil {
 				lock.Lock()
 				errs = append(errs, err)
 				lock.Unlock()
 			}
-		}(url, refer, partFileName, bar)
+		}(part, partFileName)
 	}
 	wgp.Wait()
 	if len(errs) > 0 {
 		return errs[0]
 	}
-	bar.Finish()
+	downloader.bar.Finish()
 
-	if v.Type != "video" {
+	if data.Type != types.DataTypeVideo {
 		return nil
 	}
-	// merge
+
 	fmt.Printf("Merging video parts into %s\n", mergedFilePath)
-	if v.Site == "YouTube youtube.com" {
-		err = utils.MergeAudioAndVideo(parts, mergedFilePath)
-	} else {
-		err = utils.MergeToMP4(parts, mergedFilePath, title)
+	if stream.Ext == "mp4" {
+		return utils.MergeToMP4(parts, mergedFilePath, title)
 	}
-
-	return err
+	return utils.MergeFilesWithSameExtension(parts, mergedFilePath)
 }
diff --git a/downloader/downloader_test.go b/downloader/downloader_test.go
index 6a9a32260..c13f89e7f 100644
--- a/downloader/downloader_test.go
+++ b/downloader/downloader_test.go
@@ -1,31 +1,26 @@
 package downloader
 
 import (
-	// "os"
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 )
 
-func init() {
-	config.RetryTimes = 100
-	config.ThreadNumber = 1
-}
-
 func TestDownload(t *testing.T) {
 	testCases := []struct {
 		name string
-		data Data
+		data *types.Data
 	}{
 		{
 			name: "normal test",
-			data: Data{
+			data: &types.Data{
 				Site:  "douyin",
 				Title: "test",
-				Type:  "video",
-				Streams: map[string]Stream{
+				Type:  types.DataTypeVideo,
+				Streams: map[string]*types.Stream{
 					"default": {
-						URLs: []URL{
+						ID: "default",
+						Parts: []*types.Part{
 							{
 								URL:  "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f9a0000bc117isuatl67cees890&line=0",
 								Size: 4927877,
@@ -38,13 +33,14 @@ func TestDownload(t *testing.T) {
 		},
 		{
 			name: "multi-stream test",
-			data: Data{
+			data: &types.Data{
 				Site:  "douyin",
 				Title: "test2",
-				Type:  "video",
-				Streams: map[string]Stream{
+				Type:  types.DataTypeVideo,
+				Streams: map[string]*types.Stream{
 					"miaopai": {
-						URLs: []URL{
+						ID: "miaopai",
+						Parts: []*types.Part{
 							{
 								URL:  "https://txycdn.miaopai.com/stream/KwR26jUGh2ySnVjYbQiFmomNjP14LtMU3vi6sQ__.mp4?ssig=6594aa01a78e78f50c65c164d186ba9e&time_stamp=1537070910786",
 								Size: 4011590,
@@ -54,7 +50,8 @@ func TestDownload(t *testing.T) {
 						Size: 4011590,
 					},
 					"douyin": {
-						URLs: []URL{
+						ID: "douyin",
+						Parts: []*types.Part{
 							{
 								URL:  "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f9a0000bc117isuatl67cees890&line=0",
 								Size: 4927877,
@@ -68,13 +65,14 @@ func TestDownload(t *testing.T) {
 		},
 		{
 			name: "image test",
-			data: Data{
+			data: &types.Data{
 				Site:  "bcy",
 				Title: "bcy image test",
-				Type:  "image",
-				Streams: map[string]Stream{
+				Type:  types.DataTypeImage,
+				Streams: map[string]*types.Stream{
 					"default": {
-						URLs: []URL{
+						ID: "default",
+						Parts: []*types.Part{
 							{
 								URL:  "http://img5.bcyimg.com/coser/143767/post/c0j7x/0d713eb41a614053ac6a3b146914f6bc.jpg/w650",
 								Size: 56107,
@@ -92,7 +90,7 @@ func TestDownload(t *testing.T) {
 		},
 	}
 	for _, testCase := range testCases {
-		err := Download(testCase.data, "", 10)
+		err := New(Options{}).Download(testCase.data)
 		if err != nil {
 			t.Error(err)
 		}
diff --git a/downloader/types.go b/downloader/types.go
index 7ba7c880c..b0f0c9f18 100644
--- a/downloader/types.go
+++ b/downloader/types.go
@@ -1,124 +1,6 @@
 package downloader
 
-import (
-	"fmt"
-	"sort"
-
-	"github.com/fatih/color"
-
-	"github.com/iawia002/annie/config"
-)
-
-// URL data struct for single URL information
-type URL struct {
-	URL  string `json:"url"`
-	Size int64  `json:"size"`
-	Ext  string `json:"ext"`
-}
-
-// Stream data struct for each stream
-type Stream struct {
-	// [URL: {URL, Size, Ext}, ...]
-	// Some video files have multiple fragments
-	// and support for downloading multiple image files at once
-	URLs    []URL  `json:"urls"`
-	Quality string `json:"quality"`
-	// total size of all urls
-	Size int64 `json:"size"`
-
-	// name used in sortedStreams
-	name string
-}
-
-// Data data struct for video information
-type Data struct {
-	Site  string `json:"site"`
-	Title string `json:"title"`
-	Type  string `json:"type"`
-	// each stream has it's own URLs and Quality
-	Streams       map[string]Stream `json:"streams"`
-	sortedStreams []Stream
-
-	// Err is used to record whether an error occurred when extracting data.
-	// It is used to record the error information corresponding to each url when extracting the list data.
-	// NOTE(iawia002): err is only used in Data list
-	Err error `json:"-"`
-	// URL is used to record the address of this download
-	URL string `json:"url"`
-}
-
-// EmptyData returns an "empty" Data object with the given URL and error
-func EmptyData(url string, err error) Data {
-	return Data{
-		URL: url,
-		Err: err,
-	}
-}
-
-func (data *Stream) calculateTotalSize() {
-	var size int64
-	for _, urlData := range data.URLs {
-		size += urlData.Size
-	}
-	data.Size = size
-}
-
-func (data Stream) printStream() {
-	blue := color.New(color.FgBlue)
-	cyan := color.New(color.FgCyan)
-	blue.Println(fmt.Sprintf("     [%s]  -------------------", data.name))
-	if data.Quality != "" {
-		cyan.Printf("     Quality:         ")
-		fmt.Println(data.Quality)
-	}
-	cyan.Printf("     Size:            ")
-	if data.Size == 0 {
-		data.calculateTotalSize()
-	}
-	fmt.Printf("%.2f MiB (%d Bytes)\n", float64(data.Size)/(1024*1024), data.Size)
-	cyan.Printf("     # download with: ")
-	fmt.Printf("annie -f %s ...\n\n", data.name)
-}
-
-func (v *Data) genSortedStreams() {
-	for k, data := range v.Streams {
-		if data.Size == 0 {
-			data.calculateTotalSize()
-		}
-		data.name = k
-		v.Streams[k] = data
-		v.sortedStreams = append(v.sortedStreams, data)
-	}
-	if len(v.Streams) > 1 {
-		sort.Slice(
-			v.sortedStreams, func(i, j int) bool { return v.sortedStreams[i].Size > v.sortedStreams[j].Size },
-		)
-	}
-}
-
-func (v *Data) printInfo(stream string) {
-	cyan := color.New(color.FgCyan)
-	fmt.Println()
-	cyan.Printf(" Site:      ")
-	fmt.Println(v.Site)
-	cyan.Printf(" Title:     ")
-	fmt.Println(v.Title)
-	cyan.Printf(" Type:      ")
-	fmt.Println(v.Type)
-	if config.InfoOnly {
-		cyan.Printf(" Streams:   ")
-		fmt.Println("# All available quality")
-		for _, data := range v.sortedStreams {
-			data.printStream()
-		}
-	} else {
-		cyan.Printf(" Stream:   ")
-		fmt.Println()
-		v.Streams[stream].printStream()
-	}
-}
-
-// Aria2RPCData json RPC 2.0 for Aria2
+// Aria2RPCData defines the data structure of json RPC 2.0 info for Aria2
 type Aria2RPCData struct {
 	// More info about RPC interface please refer to
 	// https://aria2.github.io/manual/en/html/aria2c.html#rpc-interface
@@ -130,7 +12,7 @@ type Aria2RPCData struct {
 	Params [3]interface{} `json:"params"`
 }
 
-// Aria2Input options for `aria2.addUri`
+// Aria2Input is options for `aria2.addUri`
 // https://aria2.github.io/manual/en/html/aria2c.html#id3
 type Aria2Input struct {
 	// The file name of the downloaded file
@@ -139,6 +21,7 @@ type Aria2Input struct {
 	Header []string `json:"header"`
 }
 
+// FilePartMeta defines the data structure of file meta info.
 type FilePartMeta struct {
 	Index float32
 	Start int64
diff --git a/downloader/utils.go b/downloader/utils.go
new file mode 100644
index 000000000..fba9ea58c
--- /dev/null
+++ b/downloader/utils.go
@@ -0,0 +1,68 @@
+package downloader
+
+import (
+	"fmt"
+	"sort"
+
+	"github.com/fatih/color"
+
+	"github.com/iawia002/annie/extractors/types"
+)
+
+var (
+	blue = color.New(color.FgBlue)
+	cyan = color.New(color.FgCyan)
+)
+
+func genSortedStreams(streams map[string]*types.Stream) []*types.Stream {
+	sortedStreams := make([]*types.Stream, 0, len(streams))
+	for _, data := range streams {
+		sortedStreams = append(sortedStreams, data)
+	}
+	if len(sortedStreams) > 1 {
+		sort.Slice(
+			sortedStreams, func(i, j int) bool { return sortedStreams[i].Size > sortedStreams[j].Size },
+		)
+	}
+	return sortedStreams
+}
+
+func printHeader(data *types.Data) {
+	fmt.Println()
+	cyan.Printf(" Site:      ") // nolint
+	fmt.Println(data.Site)
+	cyan.Printf(" Title:     ") // nolint
+	fmt.Println(data.Title)
+	cyan.Printf(" Type:      ") // nolint
+	fmt.Println(data.Type)
+}
+
+func printStream(stream *types.Stream) {
+	blue.Println(fmt.Sprintf("     [%s]  -------------------", stream.ID)) // nolint
+	if stream.Quality != "" {
+		cyan.Printf("     Quality:         ") // nolint
+		fmt.Println(stream.Quality)
+	}
+	cyan.Printf("     Size:            ") // nolint
+	fmt.Printf("%.2f MiB (%d Bytes)\n", float64(stream.Size)/(1024*1024), stream.Size)
+	cyan.Printf("     # download with: ") // nolint
+	fmt.Printf("annie -f %s ...\n\n", stream.ID)
+}
+
+func printInfo(data *types.Data, sortedStreams []*types.Stream) {
+	printHeader(data)
+
+	cyan.Printf(" Streams:   ") // nolint
+	fmt.Println("# All available quality")
+	for _, stream := range sortedStreams {
+		printStream(stream)
+	}
+}
+
+func printStreamInfo(data *types.Data, stream *types.Stream) {
+	printHeader(data)
+
+	cyan.Printf(" Stream:   ") // nolint
+	fmt.Println()
+	printStream(stream)
+}
diff --git a/extractors/bcy/bcy.go b/extractors/bcy/bcy.go
index 8617998ce..a4958915c 100644
--- a/extractors/bcy/bcy.go
+++ b/extractors/bcy/bcy.go
@@ -5,8 +5,7 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/parser"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
@@ -22,8 +21,15 @@ type bcyData struct {
 	} `json:"detail"`
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	html, err := request.Get(url, url, nil)
 	if err != nil {
 		return nil, err
@@ -33,7 +39,7 @@ func Extract(url string) ([]downloader.Data, error) {
 	rep := strings.NewReplacer(`\"`, `"`, `\\`, `\`)
 	realURLs := utils.MatchOneOf(html, `JSON.parse\("(.+?)"\);`)
 	if realURLs == nil || len(realURLs) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	jsonString := rep.Replace(realURLs[1])
 
@@ -48,7 +54,7 @@ func Extract(url string) ([]downloader.Data, error) {
 	}
 	title := strings.Replace(parser.Title(doc), " - 半次元 banciyuan - ACG爱好者社区", "", -1)
 
-	urls := make([]downloader.URL, 0, len(data.Detail.PostData.Multi))
+	parts := make([]*types.Part, 0, len(data.Detail.PostData.Multi))
 	var totalSize int64
 	for _, img := range data.Detail.PostData.Multi {
 		size, err := request.Size(img.OriginalPath, url)
@@ -60,23 +66,23 @@ func Extract(url string) ([]downloader.Data, error) {
 		if err != nil {
 			return nil, err
 		}
-		urls = append(urls, downloader.URL{
+		parts = append(parts, &types.Part{
 			URL:  img.OriginalPath,
 			Size: size,
 			Ext:  ext,
 		})
 	}
-	streams := map[string]downloader.Stream{
+	streams := map[string]*types.Stream{
 		"default": {
-			URLs: urls,
-			Size: totalSize,
+			Parts: parts,
+			Size:  totalSize,
 		},
 	}
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "半次元 bcy.net",
 			Title:   title,
-			Type:    "image",
+			Type:    types.DataTypeImage,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/bcy/bcy_test.go b/extractors/bcy/bcy_test.go
index b785da7d1..fd021d58c 100644
--- a/extractors/bcy/bcy_test.go
+++ b/extractors/bcy/bcy_test.go
@@ -3,13 +3,11 @@ package bcy
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 100
 	tests := []struct {
 		name string
 		args test.Args
@@ -25,7 +23,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/bilibili/bilibili.go b/extractors/bilibili/bilibili.go
index 05627bb33..231b3978a 100644
--- a/extractors/bilibili/bilibili.go
+++ b/extractors/bilibili/bilibili.go
@@ -7,9 +7,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/iawia002/annie/config"
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/parser"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
@@ -32,13 +30,13 @@ const referer = "https://www.bilibili.com"
 
 var utoken string
 
-func genAPI(aid, cid int, bangumi bool, quality string, seasonType string) (string, error) {
+func genAPI(aid, cid int, bangumi bool, quality, seasonType, cookie string) (string, error) {
 	var (
 		err        error
 		baseAPIURL string
 		params     string
 	)
-	if config.Cookie != "" && utoken == "" {
+	if cookie != "" && utoken == "" {
 		utoken, err = request.Get(
 			fmt.Sprintf("%said=%d&cid=%d", bilibiliTokenAPI, aid, cid),
 			referer,
@@ -83,18 +81,18 @@ func genAPI(aid, cid int, bangumi bool, quality string, seasonType string) (stri
 	return api, nil
 }
 
-func genURL(durl []dURLData) ([]downloader.URL, int64) {
+func genParts(durl []dURLData) ([]*types.Part, int64) {
 	var size int64
-	urls := make([]downloader.URL, len(durl))
+	parts := make([]*types.Part, len(durl))
 	for index, data := range durl {
 		size += data.Size
-		urls[index] = downloader.URL{
+		parts[index] = &types.Part{
 			URL:  data.URL,
 			Size: data.Size,
 			Ext:  "flv",
 		}
 	}
-	return urls, size
+	return parts, size
 }
 
 type bilibiliOptions struct {
@@ -105,16 +103,17 @@ type bilibiliOptions struct {
 	cid      int
 	page     int
 	subtitle string
+	cookie   string
 }
 
-func extractBangumi(url, html string) ([]downloader.Data, error) {
+func extractBangumi(url, html string, extractOption types.Options) ([]*types.Data, error) {
 	dataString := utils.MatchOneOf(html, `window.__INITIAL_STATE__=(.+?);\(function`)[1]
 	var data bangumiData
 	err := json.Unmarshal([]byte(dataString), &data)
 	if err != nil {
 		return nil, err
 	}
-	if !config.Playlist {
+	if !extractOption.Playlist {
 		options := bilibiliOptions{
 			url:     url,
 			html:    html,
@@ -122,13 +121,13 @@ func extractBangumi(url, html string) ([]downloader.Data, error) {
 			aid:     data.EpInfo.Aid,
 			cid:     data.EpInfo.Cid,
 		}
-		return []downloader.Data{bilibiliDownload(options)}, nil
+		return []*types.Data{bilibiliDownload(options, extractOption)}, nil
 	}
 
 	// handle bangumi playlist
-	needDownloadItems := utils.NeedDownloadList(len(data.EpList))
-	extractedData := make([]downloader.Data, len(needDownloadItems))
-	wgp := utils.NewWaitGroupPool(config.ThreadNumber)
+	needDownloadItems := utils.NeedDownloadList(extractOption.Items, extractOption.ItemStart, extractOption.ItemEnd, len(data.EpList))
+	extractedData := make([]*types.Data, len(needDownloadItems))
+	wgp := utils.NewWaitGroupPool(extractOption.ThreadNumber)
 	dataIndex := 0
 	for index, u := range data.EpList {
 		if !utils.ItemInSlice(index+1, needDownloadItems) {
@@ -146,9 +145,9 @@ func extractBangumi(url, html string) ([]downloader.Data, error) {
 			aid:     u.Aid,
 			cid:     u.Cid,
 		}
-		go func(index int, options bilibiliOptions, extractedData []downloader.Data) {
+		go func(index int, options bilibiliOptions, extractedData []*types.Data) {
 			defer wgp.Done()
-			extractedData[index] = bilibiliDownload(options)
+			extractedData[index] = bilibiliDownload(options, extractOption)
 		}(dataIndex, options, extractedData)
 		dataIndex++
 	}
@@ -171,12 +170,12 @@ func getMultiPageData(html string) (*multiPage, error) {
 	return &data, nil
 }
 
-func extractNormalVideo(url, html string) ([]downloader.Data, error) {
+func extractNormalVideo(url, html string, extractOption types.Options) ([]*types.Data, error) {
 	pageData, err := getMultiPageData(html)
 	if err != nil {
 		return nil, err
 	}
-	if !config.Playlist {
+	if !extractOption.Playlist {
 		// handle URL that has a playlist, mainly for unified titles
 		// <h1> tag does not include subtitles
 		// bangumi doesn't need this
@@ -191,7 +190,7 @@ func extractNormalVideo(url, html string) ([]downloader.Data, error) {
 		}
 
 		if len(pageData.VideoData.Pages) < p || p < 1 {
-			return nil, extractors.ErrURLParseFailed
+			return nil, types.ErrURLParseFailed
 		}
 
 		page := pageData.VideoData.Pages[p-1]
@@ -208,14 +207,14 @@ func extractNormalVideo(url, html string) ([]downloader.Data, error) {
 		} else {
 			options.subtitle = page.Part
 		}
-		return []downloader.Data{bilibiliDownload(options)}, nil
+		return []*types.Data{bilibiliDownload(options, extractOption)}, nil
 	}
 
 	// handle normal video playlist
 	// https://www.bilibili.com/video/av20827366/?p=1
-	needDownloadItems := utils.NeedDownloadList(len(pageData.VideoData.Pages))
-	extractedData := make([]downloader.Data, len(needDownloadItems))
-	wgp := utils.NewWaitGroupPool(config.ThreadNumber)
+	needDownloadItems := utils.NeedDownloadList(extractOption.Items, extractOption.ItemStart, extractOption.ItemEnd, len(pageData.VideoData.Pages))
+	extractedData := make([]*types.Data, len(needDownloadItems))
+	wgp := utils.NewWaitGroupPool(extractOption.ThreadNumber)
 	dataIndex := 0
 	for index, u := range pageData.VideoData.Pages {
 		if !utils.ItemInSlice(index+1, needDownloadItems) {
@@ -230,9 +229,9 @@ func extractNormalVideo(url, html string) ([]downloader.Data, error) {
 			subtitle: u.Part,
 			page:     u.Page,
 		}
-		go func(index int, options bilibiliOptions, extractedData []downloader.Data) {
+		go func(index int, options bilibiliOptions, extractedData []*types.Data) {
 			defer wgp.Done()
-			extractedData[index] = bilibiliDownload(options)
+			extractedData[index] = bilibiliDownload(options, extractOption)
 		}(dataIndex, options, extractedData)
 		dataIndex++
 	}
@@ -240,8 +239,15 @@ func extractNormalVideo(url, html string) ([]downloader.Data, error) {
 	return extractedData, nil
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	var err error
 	html, err := request.Get(url, referer, nil)
 	if err != nil {
@@ -249,14 +255,14 @@ func Extract(url string) ([]downloader.Data, error) {
 	}
 	if strings.Contains(url, "bangumi") {
 		// handle bangumi
-		return extractBangumi(url, html)
+		return extractBangumi(url, html, option)
 	}
 	// handle normal video
-	return extractNormalVideo(url, html)
+	return extractNormalVideo(url, html, option)
 }
 
 // bilibiliDownload is the download function for a single URL
-func bilibiliDownload(options bilibiliOptions) downloader.Data {
+func bilibiliDownload(options bilibiliOptions, extractOption types.Options) *types.Data {
 	var (
 		err        error
 		html       string
@@ -268,7 +274,7 @@ func bilibiliDownload(options bilibiliOptions) downloader.Data {
 	} else {
 		html, err = request.Get(options.url, referer, nil)
 		if err != nil {
-			return downloader.EmptyData(options.url, err)
+			return types.EmptyData(options.url, err)
 		}
 	}
 	if options.bangumi {
@@ -278,34 +284,34 @@ func bilibiliDownload(options bilibiliOptions) downloader.Data {
 	// Get "accept_quality" and "accept_description"
 	// "accept_description":["高清 1080P","高清 720P","清晰 480P","流畅 360P"],
 	// "accept_quality":[80,48,32,16],
-	api, err := genAPI(options.aid, options.cid, options.bangumi, "15", seasonType)
+	api, err := genAPI(options.aid, options.cid, options.bangumi, "15", seasonType, options.cookie)
 	if err != nil {
-		return downloader.EmptyData(options.url, err)
+		return types.EmptyData(options.url, err)
 	}
 	jsonString, err := request.Get(api, referer, nil)
 	if err != nil {
-		return downloader.EmptyData(options.url, err)
+		return types.EmptyData(options.url, err)
 	}
 	var quality qualityInfo
 	err = json.Unmarshal([]byte(jsonString), &quality)
 	if err != nil {
-		return downloader.EmptyData(options.url, err)
+		return types.EmptyData(options.url, err)
 	}
 
-	streams := make(map[string]downloader.Stream, len(quality.Quality))
+	streams := make(map[string]*types.Stream, len(quality.Quality))
 	for _, q := range quality.Quality {
-		apiURL, err := genAPI(options.aid, options.cid, options.bangumi, strconv.Itoa(q), seasonType)
+		apiURL, err := genAPI(options.aid, options.cid, options.bangumi, strconv.Itoa(q), seasonType, options.cookie)
 		if err != nil {
-			return downloader.EmptyData(options.url, err)
+			return types.EmptyData(options.url, err)
 		}
 		jsonString, err := request.Get(apiURL, referer, nil)
 		if err != nil {
-			return downloader.EmptyData(options.url, err)
+			return types.EmptyData(options.url, err)
 		}
 		var data bilibiliData
 		err = json.Unmarshal([]byte(jsonString), &data)
 		if err != nil {
-			return downloader.EmptyData(options.url, err)
+			return types.EmptyData(options.url, err)
 		}
 
 		// Avoid duplicate streams
@@ -313,9 +319,9 @@ func bilibiliDownload(options bilibiliOptions) downloader.Data {
 			continue
 		}
 
-		urls, size := genURL(data.DURL)
-		streams[strconv.Itoa(data.Quality)] = downloader.Stream{
-			URLs:    urls,
+		parts, size := genParts(data.DURL)
+		streams[strconv.Itoa(data.Quality)] = &types.Stream{
+			Parts:   parts,
 			Size:    size,
 			Quality: qualityString[data.Quality],
 		}
@@ -324,30 +330,26 @@ func bilibiliDownload(options bilibiliOptions) downloader.Data {
 	// get the title
 	doc, err := parser.GetDoc(html)
 	if err != nil {
-		return downloader.EmptyData(options.url, err)
+		return types.EmptyData(options.url, err)
 	}
 	title := parser.Title(doc)
 	if options.subtitle != "" {
-		if config.EpisodeTitleOnly {
+		if extractOption.EpisodeTitleOnly {
 			title = fmt.Sprintf("P%d %s", options.page, options.subtitle)
 		} else {
 			title = fmt.Sprintf("%s P%d %s", title, options.page, options.subtitle)
 		}
 	}
 
-	err = downloader.Caption(
-		fmt.Sprintf("https://comment.bilibili.com/%d.xml", options.cid),
-		options.url, title, "xml",
-	)
-	if err != nil {
-		return downloader.EmptyData(options.url, err)
-	}
-
-	return downloader.Data{
+	return &types.Data{
 		Site:    "哔哩哔哩 bilibili.com",
 		Title:   title,
-		Type:    "video",
+		Type:    types.DataTypeVideo,
 		Streams: streams,
-		URL:     options.url,
+		Caption: &types.Part{
+			URL: fmt.Sprintf("https://comment.bilibili.com/%d.xml", options.cid),
+			Ext: "xml",
+		},
+		URL: options.url,
 	}
 }
diff --git a/extractors/bilibili/bilibili_test.go b/extractors/bilibili/bilibili_test.go
index a1b87fd05..6e6b90633 100644
--- a/extractors/bilibili/bilibili_test.go
+++ b/extractors/bilibili/bilibili_test.go
@@ -3,14 +3,11 @@ package bilibili
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
-	"github.com/iawia002/annie/downloader"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestBilibili(t *testing.T) {
-	config.InfoOnly = true
-	config.ThreadNumber = 9 // travis out of memory issue
 	tests := []struct {
 		name     string
 		args     test.Args
@@ -72,18 +69,18 @@ func TestBilibili(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			var (
-				data []downloader.Data
+				data []*types.Data
 				err  error
 			)
-
 			if tt.playlist {
 				// for playlist, we don't check the data
-				config.Playlist = true
-				_, err = Extract(tt.args.URL)
+				_, err = New().Extract(tt.args.URL, types.Options{
+					Playlist:     true,
+					ThreadNumber: 9,
+				})
 				test.CheckError(t, err)
 			} else {
-				config.Playlist = false
-				data, err = Extract(tt.args.URL)
+				data, err = New().Extract(tt.args.URL, types.Options{})
 				test.CheckError(t, err)
 				test.Check(t, tt.args, data[0])
 			}
diff --git a/extractors/defs.go b/extractors/defs.go
deleted file mode 100644
index 99777b8fc..000000000
--- a/extractors/defs.go
+++ /dev/null
@@ -1,8 +0,0 @@
-package extractors
-
-import (
-	"errors"
-)
-
-var ErrURLParseFailed = errors.New("url parse failed")
-var ErrLoginRequired = errors.New("login required")
diff --git a/extractors/douyin/douyin.go b/extractors/douyin/douyin.go
index b92db9f51..911ee60d7 100644
--- a/extractors/douyin/douyin.go
+++ b/extractors/douyin/douyin.go
@@ -1,29 +1,39 @@
 package douyin
 
 import (
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type data struct {
+	ItemList []struct {
+		Desc string `json:"desc"`
+	} `json:"item_list"`
+}
+
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	var err error
 	html, err := request.Get(url, url, nil)
 	if err != nil {
 		return nil, err
 	}
-	var title string
-	desc := utils.MatchOneOf(html, `<p class="desc">(.+?)</p>`)
-	if desc != nil {
-		title = desc[1]
-	} else {
-		title = "抖音短视频"
-	}
+
 	realURLs := utils.MatchOneOf(html, `playAddr: "(.+?)"`)
 	if realURLs == nil || len(realURLs) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	realURL := realURLs[1]
 
@@ -31,22 +41,48 @@ func Extract(url string) ([]downloader.Data, error) {
 	if err != nil {
 		return nil, err
 	}
-	urlData := downloader.URL{
+	urlData := &types.Part{
 		URL:  realURL,
 		Size: size,
 		Ext:  "mp4",
 	}
-	streams := map[string]downloader.Stream{
+	streams := map[string]*types.Stream{
 		"default": {
-			URLs: []downloader.URL{urlData},
-			Size: size,
+			Parts: []*types.Part{urlData},
+			Size:  size,
 		},
 	}
-	return []downloader.Data{
+
+	videoIDs := utils.MatchOneOf(url, `/video/(\d+)`)
+	if len(videoIDs) == 0 {
+		return nil, errors.New("unable to get video ID")
+	}
+	videoID := videoIDs[1]
+
+	dytks := utils.MatchOneOf(html, `dytk: "(.+?)"`)
+	if len(dytks) == 0 {
+		return nil, errors.New("unable to get dytk info")
+	}
+	dytk := dytks[1]
+
+	apiDataString, err := request.Get(
+		fmt.Sprintf("https://www.douyin.com/web/api/v2/aweme/iteminfo/?item_ids=%s&dytk=%s", videoID, dytk),
+		url, nil,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	var apiData data
+	if err = json.Unmarshal([]byte(apiDataString), &apiData); err != nil {
+		return nil, err
+	}
+
+	return []*types.Data{
 		{
 			Site:    "抖音 douyin.com",
-			Title:   title,
-			Type:    "video",
+			Title:   apiData.ItemList[0].Desc,
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/douyin/douyin_test.go b/extractors/douyin/douyin_test.go
index ca10121c3..e6f09690b 100644
--- a/extractors/douyin/douyin_test.go
+++ b/extractors/douyin/douyin_test.go
@@ -3,13 +3,11 @@ package douyin
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 100
 	tests := []struct {
 		name string
 		args test.Args
@@ -24,7 +22,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/douyu/douyu.go b/extractors/douyu/douyu.go
index 4f512fc13..2052d8eea 100644
--- a/extractors/douyu/douyu.go
+++ b/extractors/douyu/douyu.go
@@ -4,8 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
@@ -48,8 +47,15 @@ func douyuM3u8(url string) ([]douyuURLInfo, int64, error) {
 	return data, totalSize, nil
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	var err error
 	liveVid := utils.MatchOneOf(url, `https?://www.douyu.com/(\S+)`)
 	if liveVid != nil {
@@ -62,13 +68,13 @@ func Extract(url string) ([]downloader.Data, error) {
 	}
 	titles := utils.MatchOneOf(html, `<title>(.*?)</title>`)
 	if titles == nil || len(titles) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	title := titles[1]
 
 	vids := utils.MatchOneOf(url, `https?://v.douyu.com/show/(\S+)`)
 	if vids == nil || len(vids) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	vid := vids[1]
 
@@ -76,33 +82,35 @@ func Extract(url string) ([]downloader.Data, error) {
 	if err != nil {
 		return nil, err
 	}
-	var dataDict douyuData
-	json.Unmarshal([]byte(dataString), &dataDict)
+	dataDict := new(douyuData)
+	if err := json.Unmarshal([]byte(dataString), dataDict); err != nil {
+		return nil, err
+	}
 
 	m3u8URLs, totalSize, err := douyuM3u8(dataDict.Data.VideoURL)
 	if err != nil {
 		return nil, err
 	}
-	urls := make([]downloader.URL, len(m3u8URLs))
+	urls := make([]*types.Part, len(m3u8URLs))
 	for index, u := range m3u8URLs {
-		urls[index] = downloader.URL{
+		urls[index] = &types.Part{
 			URL:  u.URL,
 			Size: u.Size,
 			Ext:  "ts",
 		}
 	}
 
-	streams := map[string]downloader.Stream{
+	streams := map[string]*types.Stream{
 		"default": {
-			URLs: urls,
-			Size: totalSize,
+			Parts: urls,
+			Size:  totalSize,
 		},
 	}
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "斗鱼 douyu.com",
 			Title:   title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/douyu/douyu_test.go b/extractors/douyu/douyu_test.go
index 49f65f73d..1d5190f96 100644
--- a/extractors/douyu/douyu_test.go
+++ b/extractors/douyu/douyu_test.go
@@ -3,13 +3,11 @@ package douyu
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 10
 	tests := []struct {
 		name string
 		args test.Args
@@ -25,10 +23,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			// data, err := Extract(tt.args.URL)
-			// test.CheckError(t, err)
-			// test.Check(t, tt.args, data[0])
-			Extract(tt.args.URL)
+			New().Extract(tt.args.URL, types.Options{})
 		})
 	}
 }
diff --git a/extractors/extractors.go b/extractors/extractors.go
new file mode 100644
index 000000000..641bcda58
--- /dev/null
+++ b/extractors/extractors.go
@@ -0,0 +1,105 @@
+package extractors
+
+import (
+	"net/url"
+	"strings"
+
+	"github.com/iawia002/annie/extractors/bcy"
+	"github.com/iawia002/annie/extractors/bilibili"
+	"github.com/iawia002/annie/extractors/douyin"
+	"github.com/iawia002/annie/extractors/douyu"
+	"github.com/iawia002/annie/extractors/facebook"
+	"github.com/iawia002/annie/extractors/geekbang"
+	"github.com/iawia002/annie/extractors/instagram"
+	"github.com/iawia002/annie/extractors/iqiyi"
+	"github.com/iawia002/annie/extractors/mgtv"
+	"github.com/iawia002/annie/extractors/miaopai"
+	"github.com/iawia002/annie/extractors/netease"
+	"github.com/iawia002/annie/extractors/pixivision"
+	"github.com/iawia002/annie/extractors/pornhub"
+	"github.com/iawia002/annie/extractors/qq"
+	"github.com/iawia002/annie/extractors/tangdou"
+	"github.com/iawia002/annie/extractors/tiktok"
+	"github.com/iawia002/annie/extractors/tumblr"
+	"github.com/iawia002/annie/extractors/twitter"
+	"github.com/iawia002/annie/extractors/types"
+	"github.com/iawia002/annie/extractors/udn"
+	"github.com/iawia002/annie/extractors/universal"
+	"github.com/iawia002/annie/extractors/vimeo"
+	"github.com/iawia002/annie/extractors/weibo"
+	"github.com/iawia002/annie/extractors/xvideos"
+	"github.com/iawia002/annie/extractors/yinyuetai"
+	"github.com/iawia002/annie/extractors/youku"
+	"github.com/iawia002/annie/extractors/youtube"
+	"github.com/iawia002/annie/utils"
+)
+
+var extractorMap map[string]types.Extractor
+
+func init() {
+	douyinExtractor := douyin.New()
+	youtubeExtractor := youtube.New()
+
+	extractorMap = map[string]types.Extractor{
+		"": universal.New(), // universal extractor
+
+		"douyin":     douyinExtractor,
+		"iesdouyin":  douyinExtractor,
+		"bilibili":   bilibili.New(),
+		"bcy":        bcy.New(),
+		"pixivision": pixivision.New(),
+		"youku":      youku.New(),
+		"youtube":    youtubeExtractor,
+		"youtu":      youtubeExtractor, // youtu.be
+		"iqiyi":      iqiyi.New(),
+		"mgtv":       mgtv.New(),
+		"tangdou":    tangdou.New(),
+		"tumblr":     tumblr.New(),
+		"vimeo":      vimeo.New(),
+		"facebook":   facebook.New(),
+		"douyu":      douyu.New(),
+		"miaopai":    miaopai.New(),
+		"163":        netease.New(),
+		"weibo":      weibo.New(),
+		"instagram":  instagram.New(),
+		"twitter":    twitter.New(),
+		"qq":         qq.New(),
+		"yinyuetai":  yinyuetai.New(),
+		"geekbang":   geekbang.New(),
+		"pornhub":    pornhub.New(),
+		"xvideos":    xvideos.New(),
+		"udn":        udn.New(),
+		"tiktok":     tiktok.New(),
+	}
+}
+
+// Extract is the main function to extract the data.
+func Extract(u string, option types.Options) ([]*types.Data, error) {
+	u = strings.TrimSpace(u)
+	var domain string
+
+	bilibiliShortLink := utils.MatchOneOf(u, `^(av|ep)\d+`)
+	if len(bilibiliShortLink) > 1 {
+		bilibiliURL := map[string]string{
+			"av": "https://www.bilibili.com/video/",
+			"ep": "https://www.bilibili.com/bangumi/play/",
+		}
+		domain = "bilibili"
+		u = bilibiliURL[bilibiliShortLink[1]] + u
+	} else {
+		u, err := url.ParseRequestURI(u)
+		if err != nil {
+			return nil, err
+		}
+		domain = utils.Domain(u.Host)
+	}
+	extractor := extractorMap[domain]
+	videos, err := extractor.Extract(u, option)
+	if err != nil {
+		return nil, err
+	}
+	for _, v := range videos {
+		v.FillUpStreamsData()
+	}
+	return videos, nil
+}
diff --git a/extractors/facebook/facebook.go b/extractors/facebook/facebook.go
index 737d2d7bc..2760145de 100644
--- a/extractors/facebook/facebook.go
+++ b/extractors/facebook/facebook.go
@@ -3,14 +3,20 @@ package facebook
 import (
 	"fmt"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	var err error
 	html, err := request.Get(url, url, nil)
 	if err != nil {
@@ -18,11 +24,11 @@ func Extract(url string) ([]downloader.Data, error) {
 	}
 	titles := utils.MatchOneOf(html, `<title id="pageTitle">(.+)</title>`)
 	if titles == nil || len(titles) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	title := titles[1]
 
-	streams := map[string]downloader.Stream{}
+	streams := make(map[string]*types.Stream, 2)
 	for _, quality := range []string{"sd", "hd"} {
 		srcElement := utils.MatchOneOf(
 			html, fmt.Sprintf(`%s_src_no_ratelimit:"(.+?)"`, quality),
@@ -36,23 +42,23 @@ func Extract(url string) ([]downloader.Data, error) {
 		if err != nil {
 			return nil, err
 		}
-		urlData := downloader.URL{
+		urlData := &types.Part{
 			URL:  u,
 			Size: size,
 			Ext:  "mp4",
 		}
-		streams[quality] = downloader.Stream{
-			URLs:    []downloader.URL{urlData},
+		streams[quality] = &types.Stream{
+			Parts:   []*types.Part{urlData},
 			Size:    size,
 			Quality: quality,
 		}
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "Facebook facebook.com",
 			Title:   title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/facebook/facebook_test.go b/extractors/facebook/facebook_test.go
index c1c3b4b5a..44ec5a03c 100644
--- a/extractors/facebook/facebook_test.go
+++ b/extractors/facebook/facebook_test.go
@@ -3,12 +3,11 @@ package facebook
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
 	tests := []struct {
 		name string
 		args test.Args
@@ -25,7 +24,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/geekbang/geekbang.go b/extractors/geekbang/geekbang.go
index 2a2f5f460..61602b3b8 100644
--- a/extractors/geekbang/geekbang.go
+++ b/extractors/geekbang/geekbang.go
@@ -3,11 +3,11 @@ package geekbang
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"net/http"
 	"strings"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
@@ -71,22 +71,29 @@ func geekM3u8(url string) ([]geekURLInfo, error) {
 	return data, nil
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, _ types.Options) ([]*types.Data, error) {
 	var err error
 	matches := utils.MatchOneOf(url, `https?://time.geekbang.org/course/detail/(\d+)-(\d+)`)
 	if matches == nil || len(matches) < 3 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 
 	// Get video information
 	heanders := map[string]string{"Origin": "https://time.geekbang.org", "Content-Type": "application/json", "Referer": url}
-	params := strings.NewReader("{\"id\":" + string(matches[2]) + "}")
+	params := strings.NewReader(fmt.Sprintf(`{"id": %q}`, matches[2]))
 	res, err := request.Request(http.MethodPost, "https://time.geekbang.org/serv/v1/article", params, heanders)
 	if err != nil {
 		return nil, err
 	}
-	defer res.Body.Close()
+	defer res.Body.Close() // nolint
 
 	var data geekData
 	if err = json.NewDecoder(res.Body).Decode(&data); err != nil {
@@ -107,7 +114,7 @@ func Extract(url string) ([]downloader.Data, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer res.Body.Close()
+	defer res.Body.Close() // nolint
 
 	var playAuth videoPlayAuth
 	if err = json.NewDecoder(res.Body).Decode(&playAuth); err != nil {
@@ -124,7 +131,7 @@ func Extract(url string) ([]downloader.Data, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer res.Body.Close()
+	defer res.Body.Close() // nolint
 
 	var playInfo playInfo
 	if err = json.NewDecoder(res.Body).Decode(&playInfo); err != nil {
@@ -133,7 +140,7 @@ func Extract(url string) ([]downloader.Data, error) {
 
 	title := data.Data.Title
 
-	streams := make(map[string]downloader.Stream, len(playInfo.PlayInfoList.PlayInfo))
+	streams := make(map[string]*types.Stream, len(playInfo.PlayInfoList.PlayInfo))
 
 	for _, media := range playInfo.PlayInfoList.PlayInfo {
 		m3u8URLs, err := geekM3u8(media.URL)
@@ -142,27 +149,26 @@ func Extract(url string) ([]downloader.Data, error) {
 			return nil, err
 		}
 
-		urls := make([]downloader.URL, len(m3u8URLs))
+		urls := make([]*types.Part, len(m3u8URLs))
 		for index, u := range m3u8URLs {
-			urls[index] = downloader.URL{
+			urls[index] = &types.Part{
 				URL:  u.URL,
 				Size: u.Size,
 				Ext:  "ts",
 			}
 		}
 
-		streams[media.Definition] = downloader.Stream{
-			URLs:    urls,
-			Size:    media.Size,
-			Quality: media.Definition,
+		streams[media.Definition] = &types.Stream{
+			Parts: urls,
+			Size:  media.Size,
 		}
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "极客时间 geekbang.org",
 			Title:   title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/geekbang/geekbang_test.go b/extractors/geekbang/geekbang_test.go
index fef1c1558..cc5dd01f2 100644
--- a/extractors/geekbang/geekbang_test.go
+++ b/extractors/geekbang/geekbang_test.go
@@ -3,13 +3,11 @@ package geekbang
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 10
 	tests := []struct {
 		name string
 		args test.Args
@@ -25,7 +23,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/instagram/instagram.go b/extractors/instagram/instagram.go
index a8e46c396..a0ea67572 100644
--- a/extractors/instagram/instagram.go
+++ b/extractors/instagram/instagram.go
@@ -3,8 +3,7 @@ package instagram
 import (
 	"encoding/json"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/parser"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
@@ -30,8 +29,15 @@ type instagram struct {
 	} `json:"entry_data"`
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	html, err := request.Get(url, url, nil)
 	if err != nil {
 		return nil, err
@@ -45,29 +51,32 @@ func Extract(url string) ([]downloader.Data, error) {
 
 	dataStrings := utils.MatchOneOf(html, `window\._sharedData\s*=\s*(.*);`)
 	if dataStrings == nil || len(dataStrings) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	dataString := dataStrings[1]
 
 	var data instagram
 	if err = json.Unmarshal([]byte(dataString), &data); err != nil {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 
-	var realURL, dataType string
-	var size int64
-	streams := map[string]downloader.Stream{}
+	var (
+		realURL  string
+		dataType types.DataType
+		size     int64
+	)
+	streams := make(map[string]*types.Stream)
 
 	if data.EntryData.PostPage[0].Graphql.ShortcodeMedia.VideoURL != "" {
-		// Data
-		dataType = "video"
+		// Video
+		dataType = types.DataTypeVideo
 		realURL = data.EntryData.PostPage[0].Graphql.ShortcodeMedia.VideoURL
 		size, err = request.Size(realURL, url)
 		if err != nil {
 			return nil, err
 		}
-		streams["default"] = downloader.Stream{
-			URLs: []downloader.URL{
+		streams["default"] = &types.Stream{
+			Parts: []*types.Part{
 				{
 					URL:  realURL,
 					Size: size,
@@ -78,7 +87,7 @@ func Extract(url string) ([]downloader.Data, error) {
 		}
 	} else {
 		// Image
-		dataType = "image"
+		dataType = types.DataTypeImage
 		if data.EntryData.PostPage[0].Graphql.ShortcodeMedia.EdgeSidecar.Edges == nil {
 			// Single
 			realURL = data.EntryData.PostPage[0].Graphql.ShortcodeMedia.DisplayURL
@@ -86,8 +95,8 @@ func Extract(url string) ([]downloader.Data, error) {
 			if err != nil {
 				return nil, err
 			}
-			streams["default"] = downloader.Stream{
-				URLs: []downloader.URL{
+			streams["default"] = &types.Stream{
+				Parts: []*types.Part{
 					{
 						URL:  realURL,
 						Size: size,
@@ -99,14 +108,14 @@ func Extract(url string) ([]downloader.Data, error) {
 		} else {
 			// Album
 			var totalSize int64
-			var urls []downloader.URL
+			var urls []*types.Part
 			for _, u := range data.EntryData.PostPage[0].Graphql.ShortcodeMedia.EdgeSidecar.Edges {
 				realURL = u.Node.DisplayURL
 				size, err = request.Size(realURL, url)
 				if err != nil {
 					return nil, err
 				}
-				urlData := downloader.URL{
+				urlData := &types.Part{
 					URL:  realURL,
 					Size: size,
 					Ext:  "jpg",
@@ -114,14 +123,14 @@ func Extract(url string) ([]downloader.Data, error) {
 				urls = append(urls, urlData)
 				totalSize += size
 			}
-			streams["default"] = downloader.Stream{
-				URLs: urls,
-				Size: totalSize,
+			streams["default"] = &types.Stream{
+				Parts: urls,
+				Size:  totalSize,
 			}
 		}
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "Instagram instagram.com",
 			Title:   title,
diff --git a/extractors/instagram/instagram_test.go b/extractors/instagram/instagram_test.go
index 1ce4ac662..1d508a35a 100644
--- a/extractors/instagram/instagram_test.go
+++ b/extractors/instagram/instagram_test.go
@@ -3,12 +3,11 @@ package instagram
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
 	tests := []struct {
 		name string
 		args test.Args
@@ -40,7 +39,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/iqiyi/iqiyi.go b/extractors/iqiyi/iqiyi.go
index 7a3ddd6e5..ca83f3bb7 100644
--- a/extractors/iqiyi/iqiyi.go
+++ b/extractors/iqiyi/iqiyi.go
@@ -8,8 +8,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/parser"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
@@ -74,7 +73,7 @@ func getVF(params string) string {
 	return utils.Md5(params)
 }
 
-func getVPS(tvid, vid string) (iqiyi, error) {
+func getVPS(tvid, vid string) (*iqiyi, error) {
 	t := time.Now().Unix() * 1000
 	host := "http://cache.video.qiyi.com"
 	params := fmt.Sprintf(
@@ -85,15 +84,24 @@ func getVPS(tvid, vid string) (iqiyi, error) {
 	apiURL := fmt.Sprintf("%s%s&vf=%s", host, params, vf)
 	info, err := request.Get(apiURL, iqiyiReferer, nil)
 	if err != nil {
-		return iqiyi{}, err
+		return nil, err
+	}
+	data := new(iqiyi)
+	if err := json.Unmarshal([]byte(info), data); err != nil {
+		return nil, err
 	}
-	var data iqiyi
-	json.Unmarshal([]byte(info), &data)
 	return data, nil
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, _ types.Options) ([]*types.Data, error) {
 	html, err := request.Get(url, iqiyiReferer, nil)
 	if err != nil {
 		return nil, err
@@ -112,7 +120,7 @@ func Extract(url string) ([]downloader.Data, error) {
 		)
 	}
 	if tvid == nil || len(tvid) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 
 	vid := utils.MatchOneOf(
@@ -129,7 +137,7 @@ func Extract(url string) ([]downloader.Data, error) {
 		)
 	}
 	if vid == nil || len(vid) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 
 	doc, err := parser.GetDoc(html)
@@ -155,10 +163,11 @@ func Extract(url string) ([]downloader.Data, error) {
 	if videoDatas.Code != "A00000" {
 		return nil, fmt.Errorf("can't play this video: %s", videoDatas.Msg)
 	}
-	streams := map[string]downloader.Stream{}
+
+	streams := make(map[string]*types.Stream)
 	urlPrefix := videoDatas.Data.VP.Du
 	for _, video := range videoDatas.Data.VP.Tkl[0].Vs {
-		urls := make([]downloader.URL, len(video.Fs))
+		urls := make([]*types.Part, len(video.Fs))
 		for index, v := range video.Fs {
 			realURLData, err := request.Get(urlPrefix+v.L, iqiyiReferer, nil)
 			if err != nil {
@@ -172,24 +181,24 @@ func Extract(url string) ([]downloader.Data, error) {
 			if err != nil {
 				return nil, err
 			}
-			urls[index] = downloader.URL{
+			urls[index] = &types.Part{
 				URL:  realURL.L,
 				Size: v.B,
 				Ext:  ext,
 			}
 		}
-		streams[strconv.Itoa(video.Bid)] = downloader.Stream{
-			URLs:    urls,
+		streams[strconv.Itoa(video.Bid)] = &types.Stream{
+			Parts:   urls,
 			Size:    video.Vsize,
 			Quality: video.Scrsz,
 		}
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "爱奇艺 iqiyi.com",
 			Title:   title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/iqiyi/iqiyi_test.go b/extractors/iqiyi/iqiyi_test.go
index d2a5bcc1a..41b1573ab 100644
--- a/extractors/iqiyi/iqiyi_test.go
+++ b/extractors/iqiyi/iqiyi_test.go
@@ -3,13 +3,11 @@ package iqiyi
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 10
 	tests := []struct {
 		name string
 		args test.Args
@@ -44,7 +42,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/mgtv/mgtv.go b/extractors/mgtv/mgtv.go
index 8f2051a4c..698458a30 100644
--- a/extractors/mgtv/mgtv.go
+++ b/extractors/mgtv/mgtv.go
@@ -9,8 +9,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
@@ -95,8 +94,15 @@ func encodeTk2(str string) string {
 	return encodeString
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	html, err := request.Get(url, url, nil)
 	if err != nil {
 		return nil, err
@@ -110,7 +116,7 @@ func Extract(url string) ([]downloader.Data, error) {
 		vid = utils.MatchOneOf(html, `vid: (\d+),`)
 	}
 	if vid == nil || len(vid) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 
 	// API extract from https://js.mgtv.com/imgotv-miniv6/global/page/play-tv.js
@@ -160,7 +166,7 @@ func Extract(url string) ([]downloader.Data, error) {
 	)
 	mgtvStreams := mgtvData.Data.Stream
 	var addr mgtvVideoAddr
-	streams := map[string]downloader.Stream{}
+	streams := make(map[string]*types.Stream)
 	for _, stream := range mgtvStreams {
 		if stream.URL == "" {
 			continue
@@ -179,26 +185,26 @@ func Extract(url string) ([]downloader.Data, error) {
 		if err != nil {
 			return nil, err
 		}
-		urls := make([]downloader.URL, len(m3u8URLs))
+		urls := make([]*types.Part, len(m3u8URLs))
 		for index, u := range m3u8URLs {
-			urls[index] = downloader.URL{
+			urls[index] = &types.Part{
 				URL:  u.URL,
 				Size: u.Size,
 				Ext:  "ts",
 			}
 		}
-		streams[stream.Def] = downloader.Stream{
-			URLs:    urls,
+		streams[stream.Def] = &types.Stream{
+			Parts:   urls,
 			Size:    totalSize,
 			Quality: stream.Name,
 		}
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "芒果TV mgtv.com",
 			Title:   title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/mgtv/mgtv_test.go b/extractors/mgtv/mgtv_test.go
index c41eae5d9..566a81c40 100644
--- a/extractors/mgtv/mgtv_test.go
+++ b/extractors/mgtv/mgtv_test.go
@@ -3,13 +3,11 @@ package mgtv
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 20
 	tests := []struct {
 		name string
 		args test.Args
@@ -44,10 +42,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			Extract(tt.args.URL)
-			// data, err := Extract(tt.args.URL)
-			// test.CheckError(t, err)
-			// test.Check(t, tt.args, data[0])
+			New().Extract(tt.args.URL, types.Options{})
 		})
 	}
 }
diff --git a/extractors/miaopai/miaopai.go b/extractors/miaopai/miaopai.go
index 58efd6e34..8dfffb940 100644
--- a/extractors/miaopai/miaopai.go
+++ b/extractors/miaopai/miaopai.go
@@ -8,8 +8,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
@@ -39,11 +38,18 @@ func getRandomString(l int) string {
 	return strings.Join(s, "")
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	ids := utils.MatchOneOf(url, `/media/([^\./]+)`, `/show(?:/channel)?/([^\./]+)`)
 	if ids == nil || len(ids) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	id := ids[1]
 
@@ -73,23 +79,23 @@ func Extract(url string) ([]downloader.Data, error) {
 	if err != nil {
 		return nil, err
 	}
-	urlData := downloader.URL{
+	urlData := &types.Part{
 		URL:  realURL,
 		Size: size,
 		Ext:  "mp4",
 	}
-	streams := map[string]downloader.Stream{
+	streams := map[string]*types.Stream{
 		"default": {
-			URLs: []downloader.URL{urlData},
-			Size: size,
+			Parts: []*types.Part{urlData},
+			Size:  size,
 		},
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "秒拍 miaopai.com",
 			Title:   data.Data.Description,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/miaopai/miaopai_test.go b/extractors/miaopai/miaopai_test.go
index b1163d384..841381d55 100644
--- a/extractors/miaopai/miaopai_test.go
+++ b/extractors/miaopai/miaopai_test.go
@@ -3,13 +3,11 @@ package miaopai
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 10
 	tests := []struct {
 		name string
 		args test.Args
@@ -25,7 +23,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/netease/netease.go b/extractors/netease/netease.go
index ea78b7210..384ed73be 100644
--- a/extractors/netease/netease.go
+++ b/extractors/netease/netease.go
@@ -5,14 +5,20 @@ import (
 	netURL "net/url"
 	"strings"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	url = strings.Replace(url, "/#/", "/", 1)
 	vid := utils.MatchOneOf(url, `/(mv|video)\?id=(\w+)`)
 	if vid == nil {
@@ -29,13 +35,13 @@ func Extract(url string) ([]downloader.Data, error) {
 
 	titles := utils.MatchOneOf(html, `<meta property="og:title" content="(.+?)" />`)
 	if titles == nil || len(titles) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	title := titles[1]
 
 	realURLs := utils.MatchOneOf(html, `<meta property="og:video" content="(.+?)" />`)
 	if realURLs == nil || len(realURLs) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	realURL, _ := netURL.QueryUnescape(realURLs[1])
 
@@ -43,22 +49,22 @@ func Extract(url string) ([]downloader.Data, error) {
 	if err != nil {
 		return nil, err
 	}
-	urlData := downloader.URL{
+	urlData := &types.Part{
 		URL:  realURL,
 		Size: size,
 		Ext:  "mp4",
 	}
-	streams := map[string]downloader.Stream{
+	streams := map[string]*types.Stream{
 		"default": {
-			URLs: []downloader.URL{urlData},
-			Size: size,
+			Parts: []*types.Part{urlData},
+			Size:  size,
 		},
 	}
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "网易云音乐 music.163.com",
 			Title:   title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/netease/netease_test.go b/extractors/netease/netease_test.go
index 5f3914e71..c897bc43f 100644
--- a/extractors/netease/netease_test.go
+++ b/extractors/netease/netease_test.go
@@ -3,12 +3,11 @@ package netease
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
 	tests := []struct {
 		name string
 		args test.Args
@@ -32,7 +31,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/pixivision/pixivision.go b/extractors/pixivision/pixivision.go
index 846152648..b9d451a3d 100644
--- a/extractors/pixivision/pixivision.go
+++ b/extractors/pixivision/pixivision.go
@@ -1,33 +1,58 @@
 package pixivision
 
 import (
-	"github.com/iawia002/annie/downloader"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/parser"
 	"github.com/iawia002/annie/request"
+	"github.com/iawia002/annie/utils"
 )
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	html, err := request.Get(url, url, nil)
 	if err != nil {
 		return nil, err
 	}
-	title, urls, err := parser.GetImages(url, html, "am__work__illust  ", nil)
+	title, urls, err := parser.GetImages(html, "am__work__illust  ", nil)
 	if err != nil {
 		return nil, err
 	}
-	streams := map[string]downloader.Stream{
+
+	parts := make([]*types.Part, 0, len(urls))
+	for _, u := range urls {
+		_, ext, err := utils.GetNameAndExt(u)
+		if err != nil {
+			return nil, err
+		}
+		size, err := request.Size(u, url)
+		if err != nil {
+			return nil, err
+		}
+		parts = append(parts, &types.Part{
+			URL:  u,
+			Size: size,
+			Ext:  ext,
+		})
+	}
+
+	streams := map[string]*types.Stream{
 		"default": {
-			URLs: urls,
-			Size: 0,
+			Parts: parts,
 		},
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "pixivision pixivision.net",
 			Title:   title,
-			Type:    "image",
+			Type:    types.DataTypeImage,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/pixivision/pixivision_test.go b/extractors/pixivision/pixivision_test.go
index f278503b7..0ead03047 100644
--- a/extractors/pixivision/pixivision_test.go
+++ b/extractors/pixivision/pixivision_test.go
@@ -3,13 +3,11 @@ package pixivision
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 100
 	tests := []struct {
 		name string
 		args test.Args
@@ -24,7 +22,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/pornhub/pornhub.go b/extractors/pornhub/pornhub.go
index 7db8e1b40..094c4d457 100644
--- a/extractors/pornhub/pornhub.go
+++ b/extractors/pornhub/pornhub.go
@@ -5,8 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
@@ -17,8 +16,15 @@ type pornhubData struct {
 	VideoURL string          `json:"videoUrl"`
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	html, err := request.Get(url, url, nil)
 	if err != nil {
 		return nil, err
@@ -26,7 +32,7 @@ func Extract(url string) ([]downloader.Data, error) {
 
 	var title string
 	desc := utils.MatchOneOf(html, `<span class="inlineFree">(.+?)</span>`)
-	if desc != nil && len(desc) > 1 {
+	if len(desc) > 1 {
 		title = desc[1]
 	} else {
 		title = "pornhub video"
@@ -34,7 +40,7 @@ func Extract(url string) ([]downloader.Data, error) {
 
 	realURLs := utils.MatchOneOf(html, `"mediaDefinitions":(.+?),"isVertical"`)
 	if realURLs == nil || len(realURLs) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 
 	var pornhubs []pornhubData
@@ -42,7 +48,7 @@ func Extract(url string) ([]downloader.Data, error) {
 		return nil, err
 	}
 
-	streams := make(map[string]downloader.Stream, len(pornhubs))
+	streams := make(map[string]*types.Stream, len(pornhubs))
 	for _, data := range pornhubs {
 		if data.Format == "hls" {
 			continue
@@ -67,23 +73,23 @@ func Extract(url string) ([]downloader.Data, error) {
 		if err != nil {
 			return nil, err
 		}
-		urlData := downloader.URL{
+		urlData := &types.Part{
 			URL:  realURL,
 			Size: size,
 			Ext:  "mp4",
 		}
-		streams[quality] = downloader.Stream{
-			URLs:    []downloader.URL{urlData},
+		streams[quality] = &types.Stream{
+			Parts:   []*types.Part{urlData},
 			Size:    size,
 			Quality: fmt.Sprintf("%sP", quality),
 		}
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "Pornhub pornhub.com",
 			Title:   title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/pornhub/pornhub_test.go b/extractors/pornhub/pornhub_test.go
index 6adf5325c..1798c487f 100644
--- a/extractors/pornhub/pornhub_test.go
+++ b/extractors/pornhub/pornhub_test.go
@@ -3,13 +3,11 @@ package pornhub
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestPornhub(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 10
 	tests := []struct {
 		name string
 		args test.Args
@@ -24,7 +22,7 @@ func TestPornhub(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			Extract(tt.args.URL)
+			New().Extract(tt.args.URL, types.Options{})
 		})
 	}
 }
diff --git a/extractors/qq/qq.go b/extractors/qq/qq.go
index c8588dbcb..7cecef4c3 100644
--- a/extractors/qq/qq.go
+++ b/extractors/qq/qq.go
@@ -7,8 +7,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
@@ -49,8 +48,8 @@ type qqKeyInfo struct {
 
 const qqPlayerVersion string = "3.2.19.333"
 
-func genStreams(vid, cdn string, data qqVideoInfo) (map[string]downloader.Stream, error) {
-	streams := map[string]downloader.Stream{}
+func genStreams(vid, cdn string, data qqVideoInfo) (map[string]*types.Stream, error) {
+	streams := make(map[string]*types.Stream)
 	var vkey string
 	// number of fragments
 	clips := data.Vl.Vi[0].Cl.Fc
@@ -81,7 +80,7 @@ func genStreams(vid, cdn string, data qqVideoInfo) (map[string]downloader.Stream
 			fns = append(fns[:1], fns[2:]...)
 		}
 
-		var urls []downloader.URL
+		var urls []*types.Part
 		var totalSize int64
 		var filename string
 		for part := 1; part < clips+1; part++ {
@@ -107,7 +106,7 @@ func genStreams(vid, cdn string, data qqVideoInfo) (map[string]downloader.Stream
 			}
 			jsonStrings := utils.MatchOneOf(html, `QZOutputJson=(.+);$`)
 			if jsonStrings == nil || len(jsonStrings) < 2 {
-				return nil, extractors.ErrURLParseFailed
+				return nil, types.ErrURLParseFailed
 			}
 			jsonString := jsonStrings[1]
 
@@ -125,7 +124,7 @@ func genStreams(vid, cdn string, data qqVideoInfo) (map[string]downloader.Stream
 			if err != nil {
 				return nil, err
 			}
-			urlData := downloader.URL{
+			urlData := &types.Part{
 				URL:  realURL,
 				Size: size,
 				Ext:  "mp4",
@@ -133,8 +132,8 @@ func genStreams(vid, cdn string, data qqVideoInfo) (map[string]downloader.Stream
 			urls = append(urls, urlData)
 			totalSize += size
 		}
-		streams[fi.Name] = downloader.Stream{
-			URLs:    urls,
+		streams[fi.Name] = &types.Stream{
+			Parts:   urls,
 			Size:    totalSize,
 			Quality: fi.Cname,
 		}
@@ -142,11 +141,18 @@ func genStreams(vid, cdn string, data qqVideoInfo) (map[string]downloader.Stream
 	return streams, nil
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	vids := utils.MatchOneOf(url, `vid=(\w+)`, `/(\w+)\.html`)
 	if vids == nil || len(vids) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	vid := vids[1]
 
@@ -160,7 +166,7 @@ func Extract(url string) ([]downloader.Data, error) {
 			u, `vid=(\w+)`, `vid:\s*["'](\w+)`, `vid\s*=\s*["']\s*(\w+)`,
 		)
 		if vids == nil || len(vids) < 2 {
-			return nil, extractors.ErrURLParseFailed
+			return nil, types.ErrURLParseFailed
 		}
 		vid = vids[1]
 	}
@@ -175,7 +181,7 @@ func Extract(url string) ([]downloader.Data, error) {
 	}
 	jsonStrings := utils.MatchOneOf(html, `QZOutputJson=(.+);$`)
 	if jsonStrings == nil || len(jsonStrings) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	jsonString := jsonStrings[1]
 
@@ -194,11 +200,11 @@ func Extract(url string) ([]downloader.Data, error) {
 		return nil, err
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "腾讯视频 v.qq.com",
 			Title:   data.Vl.Vi[0].Ti,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/qq/qq_test.go b/extractors/qq/qq_test.go
index 139e8a712..b785049e8 100644
--- a/extractors/qq/qq_test.go
+++ b/extractors/qq/qq_test.go
@@ -3,13 +3,11 @@ package qq
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 10
 	tests := []struct {
 		name string
 		args test.Args
@@ -44,7 +42,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/tangdou/tangdou.go b/extractors/tangdou/tangdou.go
index a2a71b7e6..5c9c084ea 100644
--- a/extractors/tangdou/tangdou.go
+++ b/extractors/tangdou/tangdou.go
@@ -1,35 +1,42 @@
 package tangdou
 
 import (
-	"github.com/iawia002/annie/config"
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
 
 const referer = "http://www.tangdou.com/html/playlist/view/4173"
 
-// Extract is the main function for extracting data
-func Extract(uri string) ([]downloader.Data, error) {
-	if !config.Playlist {
-		return []downloader.Data{tangdouDownload(uri)}, nil
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
+	if !option.Playlist {
+		return []*types.Data{tangdouDownload(url)}, nil
 	}
-	html, err := request.Get(uri, referer, nil)
+
+	html, err := request.Get(url, referer, nil)
 	if err != nil {
 		return nil, err
 	}
+
 	videoIDs := utils.MatchAll(html, `<a target="tdplayer" href="(.+?)" class="title">`)
-	needDownloadItems := utils.NeedDownloadList(len(videoIDs))
-	extractedData := make([]downloader.Data, len(needDownloadItems))
-	wgp := utils.NewWaitGroupPool(config.ThreadNumber)
+	needDownloadItems := utils.NeedDownloadList(option.Items, option.ItemStart, option.ItemEnd, len(videoIDs))
+	extractedData := make([]*types.Data, len(needDownloadItems))
+	wgp := utils.NewWaitGroupPool(option.ThreadNumber)
 	dataIndex := 0
 	for index, videoID := range videoIDs {
 		if !utils.ItemInSlice(index+1, needDownloadItems) || len(videoID) < 2 {
 			continue
 		}
 		wgp.Add()
-		go func(index int, videURI string, extractedData []downloader.Data) {
+		go func(index int, videURI string, extractedData []*types.Data) {
 			defer wgp.Done()
 			extractedData[index] = tangdouDownload(videURI)
 		}(dataIndex, videoID[1], extractedData)
@@ -40,17 +47,17 @@ func Extract(uri string) ([]downloader.Data, error) {
 }
 
 // tangdouDownload download function for single url
-func tangdouDownload(uri string) downloader.Data {
+func tangdouDownload(uri string) *types.Data {
 	html, err := request.Get(uri, referer, nil)
 	if err != nil {
-		return downloader.EmptyData(uri, err)
+		return types.EmptyData(uri, err)
 	}
 
 	titles := utils.MatchOneOf(
 		html, `<div class="title">(.+?)</div>`, `<meta name="description" content="(.+?)"`, `<title>(.+?)</title>`,
 	)
 	if titles == nil || len(titles) < 2 {
-		return downloader.EmptyData(uri, extractors.ErrURLParseFailed)
+		return types.EmptyData(uri, types.ErrURLParseFailed)
 	}
 	title := titles[1]
 
@@ -63,37 +70,37 @@ func tangdouDownload(uri string) downloader.Data {
 			html, `<div class="video">\s*<script src="(.+?)"`,
 		)
 		if shareURLs == nil || len(shareURLs) < 2 {
-			return downloader.EmptyData(uri, extractors.ErrURLParseFailed)
+			return types.EmptyData(uri, types.ErrURLParseFailed)
 		}
 		shareURL := shareURLs[1]
 
 		signedVideo, err := request.Get(shareURL, uri, nil)
 		if err != nil {
-			return downloader.EmptyData(uri, err)
+			return types.EmptyData(uri, err)
 		}
 
 		realURLs := utils.MatchOneOf(
 			signedVideo, `src=\\"(.+?)\\"`,
 		)
 		if realURLs == nil || len(realURLs) < 2 {
-			return downloader.EmptyData(uri, extractors.ErrURLParseFailed)
+			return types.EmptyData(uri, types.ErrURLParseFailed)
 		}
 		realURL = realURLs[1]
 	} else {
 		if len(videoURLs) < 2 {
-			return downloader.EmptyData(uri, extractors.ErrURLParseFailed)
+			return types.EmptyData(uri, types.ErrURLParseFailed)
 		}
 		realURL = videoURLs[1]
 	}
 
 	size, err := request.Size(realURL, uri)
 	if err != nil {
-		return downloader.EmptyData(uri, err)
+		return types.EmptyData(uri, err)
 	}
 
-	streams := map[string]downloader.Stream{
+	streams := map[string]*types.Stream{
 		"default": {
-			URLs: []downloader.URL{
+			Parts: []*types.Part{
 				{
 					URL:  realURL,
 					Size: size,
@@ -104,10 +111,10 @@ func tangdouDownload(uri string) downloader.Data {
 		},
 	}
 
-	return downloader.Data{
+	return &types.Data{
 		Site:    "糖豆广场舞 tangdou.com",
 		Title:   title,
-		Type:    "video",
+		Type:    types.DataTypeVideo,
 		Streams: streams,
 		URL:     uri,
 	}
diff --git a/extractors/tangdou/tangdou_test.go b/extractors/tangdou/tangdou_test.go
index 28ddd03f6..67e8dcbdc 100644
--- a/extractors/tangdou/tangdou_test.go
+++ b/extractors/tangdou/tangdou_test.go
@@ -3,14 +3,11 @@ package tangdou
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
-	"github.com/iawia002/annie/downloader"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestTangDou(t *testing.T) {
-	config.InfoOnly = true
-	config.ThreadNumber = 9
 	tests := []struct {
 		name     string
 		args     test.Args
@@ -44,17 +41,18 @@ func TestTangDou(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			var (
-				data []downloader.Data
+				data []*types.Data
 				err  error
 			)
 			if tt.playlist {
 				// playlist mode
-				config.Playlist = true
-				_, err = Extract(tt.args.URL)
+				_, err = New().Extract(tt.args.URL, types.Options{
+					Playlist:     true,
+					ThreadNumber: 9,
+				})
 				test.CheckError(t, err)
 			} else {
-				config.Playlist = false
-				data, err = Extract(tt.args.URL)
+				data, err = New().Extract(tt.args.URL, types.Options{})
 				test.CheckError(t, err)
 				test.Check(t, tt.args, data[0])
 			}
diff --git a/extractors/tiktok/tiktok.go b/extractors/tiktok/tiktok.go
index 413ae076d..bb158234d 100644
--- a/extractors/tiktok/tiktok.go
+++ b/extractors/tiktok/tiktok.go
@@ -1,15 +1,21 @@
 package tiktok
 
 import (
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
 
-// Extract is the main function for extracting data
-func Extract(uri string) ([]downloader.Data, error) {
-	html, err := request.Get(uri, uri, nil)
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
+	html, err := request.Get(url, url, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -19,43 +25,43 @@ func Extract(uri string) ([]downloader.Data, error) {
 
 	videoScriptTag := utils.MatchOneOf(html, `<script type="application\/ld\+json" id="videoObject">(.*?)<\/script>`)
 	if videoScriptTag == nil || len(videoScriptTag) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	videoJSON := videoScriptTag[1]
-	videoURL := utils.GetStringFromJson(videoJSON, "contentUrl")
+	videoURL := utils.GetStringFromJSON(videoJSON, "contentUrl")
 
 	// We can receive the title directly from this __NEXT_DATA__ object.
 
 	nextScriptTag := utils.MatchOneOf(html, `<script id="__NEXT_DATA__" type="application\/json" crossorigin="anonymous">(.*?)<\/script>`)
 	if nextScriptTag == nil || len(nextScriptTag) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	nextJSON := nextScriptTag[1]
-	title := utils.GetStringFromJson(nextJSON, "props.pageProps.videoData.itemInfos.text")
+	title := utils.GetStringFromJSON(nextJSON, "props.pageProps.videoData.itemInfos.text")
 
-	streams := map[string]downloader.Stream{}
+	streams := make(map[string]*types.Stream)
 
-	size, err := request.Size(videoURL, uri)
+	size, err := request.Size(videoURL, url)
 	if err != nil {
 		return nil, err
 	}
-	urlData := downloader.URL{
+	urlData := &types.Part{
 		URL:  videoURL,
 		Size: size,
 		Ext:  "mp4",
 	}
-	streams["default"] = downloader.Stream{
-		URLs: []downloader.URL{urlData},
-		Size: size,
+	streams["default"] = &types.Stream{
+		Parts: []*types.Part{urlData},
+		Size:  size,
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "TikTok tiktok.com",
 			Title:   title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
-			URL:     uri,
+			URL:     url,
 		},
 	}, nil
 }
diff --git a/extractors/tiktok/tiktok_test.go b/extractors/tiktok/tiktok_test.go
index a5dedb2cf..f3fc967e7 100644
--- a/extractors/tiktok/tiktok_test.go
+++ b/extractors/tiktok/tiktok_test.go
@@ -1,13 +1,13 @@
 package tiktok
 
 import (
-	"github.com/iawia002/annie/config"
-	"github.com/iawia002/annie/test"
 	"testing"
+
+	"github.com/iawia002/annie/extractors/types"
+	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
 	tests := []struct {
 		name string
 		args test.Args
@@ -29,7 +29,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/tumblr/tumblr.go b/extractors/tumblr/tumblr.go
index ee0f30e9e..2789775b8 100644
--- a/extractors/tumblr/tumblr.go
+++ b/extractors/tumblr/tumblr.go
@@ -5,8 +5,7 @@ import (
 	"errors"
 	"strings"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/parser"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
@@ -24,34 +23,33 @@ type tumblrImage struct {
 	Image string `json:"image"`
 }
 
-func genURLData(url, referer string) (downloader.URL, int64, error) {
+func genURLData(url, referer string) (*types.Part, int64, error) {
 	size, err := request.Size(url, referer)
 	if err != nil {
-		return downloader.URL{}, 0, err
+		return nil, 0, err
 	}
 	_, ext, err := utils.GetNameAndExt(url)
 	if err != nil {
-		return downloader.URL{}, 0, err
+		return nil, 0, err
 	}
-	data := downloader.URL{
+	return &types.Part{
 		URL:  url,
 		Size: size,
 		Ext:  ext,
-	}
-	return data, size, nil
+	}, size, nil
 }
 
-func tumblrImageDownload(url, html, title string) ([]downloader.Data, error) {
+func tumblrImageDownload(url, html, title string) ([]*types.Data, error) {
 	jsonStrings := utils.MatchOneOf(
 		html, `<script type="application/ld\+json">\s*(.+?)</script>`,
 	)
 	if jsonStrings == nil || len(jsonStrings) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	jsonString := jsonStrings[1]
 
 	var totalSize int64
-	var urls []downloader.URL
+	urls := make([]*types.Part, 0, 1)
 	if strings.Contains(jsonString, `"image":{"@list"`) {
 		// there are two data structures in the same field(image)
 		var imageList tumblrImageList
@@ -79,28 +77,28 @@ func tumblrImageDownload(url, html, title string) ([]downloader.Data, error) {
 		totalSize = size
 		urls = append(urls, urlData)
 	}
-	streams := map[string]downloader.Stream{
+	streams := map[string]*types.Stream{
 		"default": {
-			URLs: urls,
-			Size: totalSize,
+			Parts: urls,
+			Size:  totalSize,
 		},
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "Tumblr tumblr.com",
 			Title:   title,
-			Type:    "image",
+			Type:    types.DataTypeImage,
 			Streams: streams,
 			URL:     url,
 		},
 	}, nil
 }
 
-func tumblrVideoDownload(url, html, title string) ([]downloader.Data, error) {
+func tumblrVideoDownload(url, html, title string) ([]*types.Data, error) {
 	videoURLs := utils.MatchOneOf(html, `<iframe src='(.+?)'`)
 	if videoURLs == nil || len(videoURLs) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	videoURL := videoURLs[1]
 
@@ -114,7 +112,7 @@ func tumblrVideoDownload(url, html, title string) ([]downloader.Data, error) {
 
 	realURLs := utils.MatchOneOf(videoHTML, `source src="(.+?)"`)
 	if realURLs == nil || len(realURLs) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	realURL := realURLs[1]
 
@@ -122,26 +120,33 @@ func tumblrVideoDownload(url, html, title string) ([]downloader.Data, error) {
 	if err != nil {
 		return nil, err
 	}
-	streams := map[string]downloader.Stream{
+	streams := map[string]*types.Stream{
 		"default": {
-			URLs: []downloader.URL{urlData},
-			Size: size,
+			Parts: []*types.Part{urlData},
+			Size:  size,
 		},
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "Tumblr tumblr.com",
 			Title:   title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
 	}, nil
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	html, err := request.Get(url, url, nil)
 	if err != nil {
 		return nil, err
diff --git a/extractors/tumblr/tumblr_test.go b/extractors/tumblr/tumblr_test.go
index 3277fabca..216a8d494 100644
--- a/extractors/tumblr/tumblr_test.go
+++ b/extractors/tumblr/tumblr_test.go
@@ -3,12 +3,11 @@ package tumblr
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
 	tests := []struct {
 		name string
 		args test.Args
@@ -31,13 +30,13 @@ func TestDownload(t *testing.T) {
 			name: "video test",
 			args: test.Args{
 				URL:   "https://boomgoestheprower.tumblr.com/post/174127507696",
-				Title: "See, that’s what the app is perfect for.",
+				Title: "Out of Context Sonic Boom",
 			},
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/twitter/twitter.go b/extractors/twitter/twitter.go
index c913b7588..7f8f88ac3 100644
--- a/extractors/twitter/twitter.go
+++ b/extractors/twitter/twitter.go
@@ -6,8 +6,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
@@ -20,22 +19,29 @@ type twitter struct {
 	Username string
 }
 
-// Extract is the main function for extracting data
-func Extract(uri string) ([]downloader.Data, error) {
-	html, err := request.Get(uri, uri, nil)
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
+	html, err := request.Get(url, url, nil)
 	if err != nil {
 		return nil, err
 	}
 
 	usernames := utils.MatchOneOf(html, `property="og:title"\s+content="(.+)"`)
 	if usernames == nil || len(usernames) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	username := usernames[1]
 
-	tweetIDs := utils.MatchOneOf(uri, `(status|statuses)/(\d+)`)
+	tweetIDs := utils.MatchOneOf(url, `(status|statuses)/(\d+)`)
 	if tweetIDs == nil || len(tweetIDs) < 3 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	tweetID := tweetIDs[2]
 
@@ -45,30 +51,30 @@ func Extract(uri string) ([]downloader.Data, error) {
 	headers := map[string]string{
 		"Authorization": "Bearer AAAAAAAAAAAAAAAAAAAAAIK1zgAAAAAA2tUWuhGZ2JceoId5GwYWU5GspY4%3DUq7gzFoCZs1QfwGoVdvSac3IniczZEYXIcDyumCauIXpcAPorE",
 	}
-	jsonString, err := request.Get(api, uri, headers)
+	jsonString, err := request.Get(api, url, headers)
 	if err != nil {
 		return nil, err
 	}
 
 	var twitterData twitter
 	if err := json.Unmarshal([]byte(jsonString), &twitterData); err != nil {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	twitterData.TweetID = tweetID
 	twitterData.Username = username
-	extractedData, err := download(twitterData, uri)
+	extractedData, err := download(twitterData, url)
 	if err != nil {
 		return nil, err
 	}
 	return extractedData, nil
 }
 
-func download(data twitter, uri string) ([]downloader.Data, error) {
+func download(data twitter, uri string) ([]*types.Data, error) {
 	var (
 		err  error
 		size int64
 	)
-	streams := make(map[string]downloader.Stream)
+	streams := make(map[string]*types.Stream)
 	switch {
 	// if video file is m3u8 and ts
 	case strings.Contains(data.Track.URL, ".m3u8"):
@@ -78,17 +84,17 @@ func download(data twitter, uri string) ([]downloader.Data, error) {
 		}
 		for index, m3u8 := range m3u8urls {
 			var totalSize int64
-			var urls []downloader.URL
 			ts, err := utils.M3u8URLs(m3u8)
 			if err != nil {
 				return nil, err
 			}
+			urls := make([]*types.Part, 0, len(ts))
 			for _, i := range ts {
 				size, err := request.Size(i, uri)
 				if err != nil {
 					return nil, err
 				}
-				temp := downloader.URL{
+				temp := &types.Part{
 					URL:  i,
 					Size: size,
 					Ext:  "ts",
@@ -98,10 +104,10 @@ func download(data twitter, uri string) ([]downloader.Data, error) {
 			}
 			qualityString := utils.MatchOneOf(m3u8, `/(\d+x\d+)/`)[1]
 			quality := strconv.Itoa(index + 1)
-			streams[quality] = downloader.Stream{
-				Quality: qualityString,
-				URLs:    urls,
+			streams[quality] = &types.Stream{
+				Parts:   urls,
 				Size:    totalSize,
+				Quality: qualityString,
 			}
 		}
 
@@ -111,22 +117,22 @@ func download(data twitter, uri string) ([]downloader.Data, error) {
 		if err != nil {
 			return nil, err
 		}
-		urlData := downloader.URL{
+		urlData := &types.Part{
 			URL:  data.Track.URL,
 			Size: size,
 			Ext:  "mp4",
 		}
-		streams["default"] = downloader.Stream{
-			URLs: []downloader.URL{urlData},
-			Size: size,
+		streams["default"] = &types.Stream{
+			Parts: []*types.Part{urlData},
+			Size:  size,
 		}
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "Twitter twitter.com",
 			Title:   fmt.Sprintf("%s %s", data.Username, data.TweetID),
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     uri,
 		},
diff --git a/extractors/twitter/twitter_test.go b/extractors/twitter/twitter_test.go
index 46d2cb4e7..6331757fe 100644
--- a/extractors/twitter/twitter_test.go
+++ b/extractors/twitter/twitter_test.go
@@ -3,13 +3,11 @@ package twitter
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 10
 	tests := []struct {
 		name string
 		args test.Args
@@ -42,7 +40,7 @@ func TestDownload(t *testing.T) {
 	// The file size changes every time (caused by CDN?), so the size is not checked here
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			Extract(tt.args.URL)
+			New().Extract(tt.args.URL, types.Options{})
 		})
 	}
 }
diff --git a/extractors/types/defs.go b/extractors/types/defs.go
new file mode 100644
index 000000000..e05240a87
--- /dev/null
+++ b/extractors/types/defs.go
@@ -0,0 +1,12 @@
+package types
+
+import (
+	"errors"
+)
+
+var (
+	// ErrURLParseFailed defines url parse failed error.
+	ErrURLParseFailed = errors.New("url parse failed")
+	// ErrLoginRequired defines login required error.
+	ErrLoginRequired = errors.New("login required")
+)
diff --git a/extractors/types/types.go b/extractors/types/types.go
new file mode 100644
index 000000000..2f7c9f39a
--- /dev/null
+++ b/extractors/types/types.go
@@ -0,0 +1,119 @@
+package types
+
+// Part is the data structure for a single part of the video stream information.
+type Part struct {
+	URL  string `json:"url"`
+	Size int64  `json:"size"`
+	Ext  string `json:"ext"`
+}
+
+// Stream is the data structure for each video stream, eg: 720P, 1080P.
+type Stream struct {
+	// eg: "1080"
+	ID string `json:"id"`
+	// eg: "1080P xxx"
+	Quality string `json:"quality"`
+	// [Part: {URL, Size, Ext}, ...]
+	// Some video stream have multiple parts,
+	// and can also be used to download multiple image files at once
+	Parts []*Part `json:"parts"`
+	// total size of all urls
+	Size int64 `json:"size"`
+	// the file extension after video parts merged
+	Ext string `json:"ext"`
+}
+
+// DataType indicates the type of extracted data, eg: video or image.
+type DataType string
+
+const (
+	// DataTypeVideo indicates the type of extracted data is the video.
+	DataTypeVideo DataType = "video"
+	// DataTypeImage indicates the type of extracted data is the image.
+	DataTypeImage DataType = "image"
+)
+
+// Data is the main data structure for the whole video data.
+type Data struct {
+	// URL is used to record the address of this download
+	URL   string   `json:"url"`
+	Site  string   `json:"site"`
+	Title string   `json:"title"`
+	Type  DataType `json:"type"`
+	// each stream has it's own Parts and Quality
+	Streams map[string]*Stream `json:"streams"`
+	// danmaku, subtitles, etc
+	Caption *Part `json:"caption"`
+	// Err is used to record whether an error occurred when extracting the list data
+	Err error `json:"err"`
+}
+
+// FillUpStreamsData fills up some data automatically.
+func (d *Data) FillUpStreamsData() {
+	for id, stream := range d.Streams {
+		// fill up ID
+		stream.ID = id
+		if stream.Quality == "" {
+			stream.Quality = id
+		}
+
+		// generate the merged file extension
+		if d.Type == DataTypeVideo && stream.Ext == "" {
+			ext := stream.Parts[0].Ext
+			// The file extension in `Parts` is used as the merged file extension by default, except for the following formats
+			switch ext {
+			// ts and flv files should be merged into an mp4 file
+			case "ts", "flv":
+				ext = "mp4"
+			}
+			stream.Ext = ext
+		}
+
+		// calculate total size
+		if stream.Size > 0 {
+			continue
+		}
+		var size int64
+		for _, part := range stream.Parts {
+			size += part.Size
+		}
+		stream.Size = size
+	}
+}
+
+// EmptyData returns an "empty" Data object with the given URL and error.
+func EmptyData(url string, err error) *Data {
+	return &Data{
+		URL: url,
+		Err: err,
+	}
+}
+
+// Options defines optional options that can be used in the extraction function.
+type Options struct {
+	// Playlist indicates if we need to extract the whole playlist rather than the single video.
+	Playlist bool
+	// Items defines wanted items from a playlist. Separated by commas like: 1,5,6,8-10.
+	Items string
+	// ItemStart defines the starting item of a playlist.
+	ItemStart int
+	// ItemEnd defines the ending item of a playlist.
+	ItemEnd int
+
+	// ThreadNumber defines how many threads will use in the extraction, only works when Playlist is true.
+	ThreadNumber int
+	Cookie       string
+
+	// EpisodeTitleOnly indicates file name of each bilibili episode doesn't include the playlist title
+	EpisodeTitleOnly bool
+
+	YoukuCcode    string
+	YoukuCkey     string
+	YoukuPassword string
+}
+
+// Extractor implements video data extraction related operations.
+type Extractor interface {
+	// Extract is the main function to extract the data.
+	Extract(url string, option Options) ([]*Data, error)
+}
diff --git a/extractors/udn/udn.go b/extractors/udn/udn.go
index 8a49b1610..442fa75af 100644
--- a/extractors/udn/udn.go
+++ b/extractors/udn/udn.go
@@ -4,8 +4,7 @@ import (
 	"errors"
 	"strings"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
@@ -19,7 +18,7 @@ const (
 )
 
 func getCDNUrl(html string) string {
-	if cdnURLs := utils.MatchOneOf(html, startFlag+"(.+?)"+endFlag); cdnURLs != nil && len(cdnURLs) > 1 && cdnURLs[1] != "" {
+	if cdnURLs := utils.MatchOneOf(html, startFlag+"(.+?)"+endFlag); len(cdnURLs) > 1 && cdnURLs[1] != "" {
 		return cdnURLs[1]
 	}
 	return ""
@@ -36,11 +35,18 @@ func prepareEmbedURL(url string) string {
 	return url
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	url = prepareEmbedURL(url)
 	if len(url) == 0 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 
 	html, err := request.Get(url, url, nil)
@@ -50,7 +56,7 @@ func Extract(url string) ([]downloader.Data, error) {
 	var title string
 	desc := utils.MatchOneOf(html, `title: '(.+?)',
         link:`)
-	if desc != nil && len(desc) > 1 {
+	if len(desc) > 1 {
 		title = desc[1]
 	} else {
 		title = "udn"
@@ -67,24 +73,24 @@ func Extract(url string) ([]downloader.Data, error) {
 	if err != nil {
 		return nil, err
 	}
-	urlData := downloader.URL{
+	urlData := &types.Part{
 		URL:  srcURL,
 		Size: size,
 		Ext:  "mp4",
 	}
 	quality := "normal"
-	streams := map[string]downloader.Stream{
+	streams := map[string]*types.Stream{
 		quality: {
-			URLs:    []downloader.URL{urlData},
+			Parts:   []*types.Part{urlData},
 			Size:    size,
 			Quality: quality,
 		},
 	}
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "udn udn.com",
 			Title:   title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/udn/udn_test.go b/extractors/udn/udn_test.go
index c02569f43..2394255a2 100644
--- a/extractors/udn/udn_test.go
+++ b/extractors/udn/udn_test.go
@@ -3,13 +3,11 @@ package udn
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestExtract(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 10
 	tests := []struct {
 		name string
 		args test.Args
@@ -25,7 +23,7 @@ func TestExtract(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/universal/universal.go b/extractors/universal/universal.go
index ccbdbab66..7e6600855 100644
--- a/extractors/universal/universal.go
+++ b/extractors/universal/universal.go
@@ -1,17 +1,20 @@
 package universal
 
 import (
-	"fmt"
-
-	"github.com/iawia002/annie/downloader"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
-	fmt.Println("\nannie doesn't support this URL right now, but it will try to download it directly")
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
 
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	filename, ext, err := utils.GetNameAndExt(url)
 	if err != nil {
 		return nil, err
@@ -20,14 +23,15 @@ func Extract(url string) ([]downloader.Data, error) {
 	if err != nil {
 		return nil, err
 	}
-	urlData := downloader.URL{
-		URL:  url,
-		Size: size,
-		Ext:  ext,
-	}
-	streams := map[string]downloader.Stream{
+	streams := map[string]*types.Stream{
 		"default": {
-			URLs: []downloader.URL{urlData},
+			Parts: []*types.Part{
+				{
+					URL:  url,
+					Size: size,
+					Ext:  ext,
+				},
+			},
 			Size: size,
 		},
 	}
@@ -36,11 +40,11 @@ func Extract(url string) ([]downloader.Data, error) {
 		return nil, err
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "Universal",
 			Title:   filename,
-			Type:    contentType,
+			Type:    types.DataType(contentType),
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/universal/universal_test.go b/extractors/universal/universal_test.go
index eca54f58d..6c042c488 100644
--- a/extractors/universal/universal_test.go
+++ b/extractors/universal/universal_test.go
@@ -3,12 +3,11 @@ package universal
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
 	tests := []struct {
 		name string
 		args test.Args
@@ -24,7 +23,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/vimeo/vimeo.go b/extractors/vimeo/vimeo.go
index e6a2b0bf9..20657aeb2 100644
--- a/extractors/vimeo/vimeo.go
+++ b/extractors/vimeo/vimeo.go
@@ -5,8 +5,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
@@ -36,8 +35,15 @@ type vimeo struct {
 	Video   vimeoVideo   `json:"video"`
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	var (
 		html, vid string
 		err       error
@@ -56,7 +62,7 @@ func Extract(url string) ([]downloader.Data, error) {
 	}
 	jsonStrings := utils.MatchOneOf(html, `var \w+\s?=\s?({.+?});`)
 	if jsonStrings == nil || len(jsonStrings) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	jsonString := jsonStrings[1]
 
@@ -65,31 +71,30 @@ func Extract(url string) ([]downloader.Data, error) {
 		return nil, err
 	}
 
-	streams := map[string]downloader.Stream{}
+	streams := make(map[string]*types.Stream, len(vimeoData.Request.Files.Progressive))
 	var size int64
-	var urlData downloader.URL
 	for _, video := range vimeoData.Request.Files.Progressive {
 		size, err = request.Size(video.URL, url)
 		if err != nil {
 			return nil, err
 		}
-		urlData = downloader.URL{
+		urlData := &types.Part{
 			URL:  video.URL,
 			Size: size,
 			Ext:  "mp4",
 		}
-		streams[strconv.Itoa(video.Profile)] = downloader.Stream{
-			URLs:    []downloader.URL{urlData},
+		streams[strconv.Itoa(video.Profile)] = &types.Stream{
+			Parts:   []*types.Part{urlData},
 			Size:    size,
 			Quality: video.Quality,
 		}
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "Vimeo vimeo.com",
 			Title:   vimeoData.Video.Title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/vimeo/vimeo_test.go b/extractors/vimeo/vimeo_test.go
index 78e71cab9..36a9723fe 100644
--- a/extractors/vimeo/vimeo_test.go
+++ b/extractors/vimeo/vimeo_test.go
@@ -3,12 +3,11 @@ package vimeo
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
 	tests := []struct {
 		name string
 		args test.Args
@@ -34,10 +33,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			Extract(tt.args.URL)
-			// data, err := Extract(tt.args.URL)
-			// test.CheckError(t, err)
-			// test.Check(t, tt.args, data[0])
+			New().Extract(tt.args.URL, types.Options{})
 		})
 	}
 }
diff --git a/extractors/weibo/weibo.go b/extractors/weibo/weibo.go
index d10bc0293..07e9aac9d 100644
--- a/extractors/weibo/weibo.go
+++ b/extractors/weibo/weibo.go
@@ -5,14 +5,13 @@ import (
 	netURL "net/url"
 	"strings"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/parser"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
 
-func downloadWeiboTV(url string) ([]downloader.Data, error) {
+func downloadWeiboTV(url string) ([]*types.Data, error) {
 	headers := map[string]string{
 		"Cookie": "SUB=_2AkMsZ8xOf8NxqwJRmP4RzGLqbo5xyQDEieKaOz2VJRMxHRl-yj83qlEotRB6B-fiobWQ5vdEoYw7bCoCdf4KyP8O3Ujq",
 	}
@@ -32,7 +31,7 @@ func downloadWeiboTV(url string) ([]downloader.Data, error) {
 	// &720=http://f.us.sinaimg.cn/004cqzndlx07oCX1kMOQ01040200vyxj0k010.mp4?label=mp4_720p&template=1280x720.20&Expires=1541041515&ssig=Fdasnr1aW6&KID=unistore,video&qType=720
 	realURLs := utils.MatchOneOf(html, `video-sources="fluency=(.+?)"`)
 	if realURLs == nil || len(realURLs) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 
 	realURL, err := netURL.PathUnescape(realURLs[1])
@@ -40,7 +39,7 @@ func downloadWeiboTV(url string) ([]downloader.Data, error) {
 		return nil, err
 	}
 	quality := []string{"480", "720"}
-	streams := make(map[string]downloader.Stream, len(quality))
+	streams := make(map[string]*types.Stream, len(quality))
 	for _, q := range quality {
 		urlList := strings.Split(realURL, fmt.Sprintf("&%s=", q))
 		u := urlList[len(urlList)-1]
@@ -51,8 +50,8 @@ func downloadWeiboTV(url string) ([]downloader.Data, error) {
 		if err != nil {
 			return nil, err
 		}
-		streams[q] = downloader.Stream{
-			URLs: []downloader.URL{
+		streams[q] = &types.Stream{
+			Parts: []*types.Part{
 				{
 					URL:  u,
 					Size: size,
@@ -63,19 +62,26 @@ func downloadWeiboTV(url string) ([]downloader.Data, error) {
 			Quality: q,
 		}
 	}
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "微博 weibo.com",
 			Title:   title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
 	}, nil
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	if !strings.Contains(url, "m.weibo.cn") {
 		if strings.Contains(url, "weibo.com/tv/v/") {
 			return downloadWeiboTV(url)
@@ -90,7 +96,7 @@ func Extract(url string) ([]downloader.Data, error) {
 		html, `"content2": "(.+?)",`, `"status_title": "(.+?)",`,
 	)
 	if titles == nil || len(titles) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	title := titles[1]
 
@@ -98,7 +104,7 @@ func Extract(url string) ([]downloader.Data, error) {
 		html, `"stream_url_hd": "(.+?)"`, `"stream_url": "(.+?)"`,
 	)
 	if realURLs == nil || len(realURLs) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	realURL := realURLs[1]
 
@@ -106,23 +112,23 @@ func Extract(url string) ([]downloader.Data, error) {
 	if err != nil {
 		return nil, err
 	}
-	urlData := downloader.URL{
+	urlData := &types.Part{
 		URL:  realURL,
 		Size: size,
 		Ext:  "mp4",
 	}
-	streams := map[string]downloader.Stream{
+	streams := map[string]*types.Stream{
 		"default": {
-			URLs: []downloader.URL{urlData},
-			Size: size,
+			Parts: []*types.Part{urlData},
+			Size:  size,
 		},
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "微博 weibo.com",
 			Title:   title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/weibo/weibo_test.go b/extractors/weibo/weibo_test.go
index 626769c9b..ee929c004 100644
--- a/extractors/weibo/weibo_test.go
+++ b/extractors/weibo/weibo_test.go
@@ -3,25 +3,15 @@ package weibo
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 10
 	tests := []struct {
 		name string
 		args test.Args
 	}{
-		{
-			name: "fid url test",
-			args: test.Args{
-				URL:   "https://weibo.com/tv/v/Ga7XazXze?fid=1034:4a65c6e343dc672789d3ba49c2463c6a",
-				Title: "看完更加睡不着了[二哈]",
-				Size:  438757,
-			},
-		},
 		{
 			name: "title test",
 			args: test.Args{
@@ -50,7 +40,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/xvideos/xvideos.go b/extractors/xvideos/xvideos.go
index 5a621ca34..afabbe9b3 100644
--- a/extractors/xvideos/xvideos.go
+++ b/extractors/xvideos/xvideos.go
@@ -1,11 +1,10 @@
 package xvideos
 
 import (
-	"fmt"
 	"strings"
 	"sync"
 
-	"github.com/iawia002/annie/downloader"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
@@ -76,42 +75,49 @@ func getSrc(html string) []*src {
 	return srcs
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	html, err := request.Get(url, url, nil)
 	if err != nil {
 		return nil, err
 	}
 	var title string
 	desc := utils.MatchOneOf(html, `<title>(.+?)</title>`)
-	if desc != nil && len(desc) > 1 {
+	if len(desc) > 1 {
 		title = desc[1]
 	} else {
 		title = "xvideos"
 	}
 
-	streams := make(map[string]downloader.Stream)
+	streams := make(map[string]*types.Stream, len(getSrc(html)))
 	for _, src := range getSrc(html) {
 		size, err := request.Size(src.url, url)
 		if err != nil {
 			return nil, err
 		}
-		urlData := downloader.URL{
+		urlData := &types.Part{
 			URL:  src.url,
 			Size: size,
 			Ext:  "mp4",
 		}
-		streams[src.quality] = downloader.Stream{
-			URLs:    []downloader.URL{urlData},
+		streams[src.quality] = &types.Stream{
+			Parts:   []*types.Part{urlData},
 			Size:    size,
-			Quality: fmt.Sprintf("%s", src.quality),
+			Quality: src.quality,
 		}
 	}
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "XVIDEOS xvideos.com",
 			Title:   title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/xvideos/xvideos_test.go b/extractors/xvideos/xvideos_test.go
index 1560ec00b..37973388a 100644
--- a/extractors/xvideos/xvideos_test.go
+++ b/extractors/xvideos/xvideos_test.go
@@ -3,13 +3,11 @@ package xvideos
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestExtract(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 10
 	tests := []struct {
 		name string
 		args test.Args
@@ -25,7 +23,7 @@ func TestExtract(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
+			data, err := New().Extract(tt.args.URL, types.Options{})
 			test.CheckError(t, err)
 			test.Check(t, tt.args, data[0])
 		})
diff --git a/extractors/yinyuetai/yinyuetai.go b/extractors/yinyuetai/yinyuetai.go
index 6f612e920..6b5653c31 100644
--- a/extractors/yinyuetai/yinyuetai.go
+++ b/extractors/yinyuetai/yinyuetai.go
@@ -5,8 +5,7 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
@@ -21,8 +20,15 @@ func genAPI(action string, param string) string {
 	return fmt.Sprintf("%s%s?json=true&%s", yinyuetaiAPI, action, param)
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	vid := utils.MatchOneOf(
 		url,
 		`https?://v.yinyuetai.com/video/(\d+)(?:\?vid=\d+)?`,
@@ -34,16 +40,16 @@ func Extract(url string) ([]downloader.Data, error) {
 	}
 	params := fmt.Sprintf("videoId=%s", vid[1])
 	// generate api url
-	apiUrl := genAPI(actionGetMvInfo, params)
+	apiURL := genAPI(actionGetMvInfo, params)
 	var err error
-	html, err := request.Get(apiUrl, url, nil)
+	html, err := request.Get(apiURL, url, nil)
 	if err != nil {
 		return nil, err
 	}
 	// parse yinyuetai data
 	data := yinyuetaiMvData{}
 	if err = json.Unmarshal([]byte(html), &data); err != nil {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	// handle api error
 	if data.Error {
@@ -53,25 +59,25 @@ func Extract(url string) ([]downloader.Data, error) {
 		return nil, errors.New(data.VideoInfo.CoreVideoInfo.ErrorMsg)
 	}
 	title := data.VideoInfo.CoreVideoInfo.VideoName
-	streams := map[string]downloader.Stream{}
+	streams := make(map[string]*types.Stream, len(data.VideoInfo.CoreVideoInfo.VideoURLModels))
 	// set streams
 	for _, model := range data.VideoInfo.CoreVideoInfo.VideoURLModels {
-		urlData := downloader.URL{
+		urlData := &types.Part{
 			URL:  model.VideoURL,
 			Size: model.FileSize,
 			Ext:  "mp4",
 		}
-		streams[model.QualityLevel] = downloader.Stream{
-			URLs:    []downloader.URL{urlData},
+		streams[model.QualityLevel] = &types.Stream{
+			Parts:   []*types.Part{urlData},
 			Size:    model.FileSize,
 			Quality: model.QualityLevelName,
 		}
 	}
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "音悦台 yinyuetai.com",
 			Title:   title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/yinyuetai/yinyuetai_test.go b/extractors/yinyuetai/yinyuetai_test.go
index b3017f9de..d452ee7bb 100644
--- a/extractors/yinyuetai/yinyuetai_test.go
+++ b/extractors/yinyuetai/yinyuetai_test.go
@@ -3,13 +3,11 @@ package yinyuetai
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 1
 	tests := []struct {
 		name string
 		args test.Args
@@ -26,7 +24,7 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			Extract(tt.args.URL)
+			New().Extract(tt.args.URL, types.Options{})
 		})
 	}
 }
diff --git a/extractors/youku/youku.go b/extractors/youku/youku.go
index b9c8b4cae..4e29d7a3e 100644
--- a/extractors/youku/youku.go
+++ b/extractors/youku/youku.go
@@ -14,9 +14,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/iawia002/annie/config"
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
@@ -79,15 +77,15 @@ func getAudioLang(lang string) string {
 
 // var ccodes = []string{"0510", "0502", "0507", "0508", "0512", "0513", "0514", "0503", "0590"}
 
-func youkuUps(vid string) (*youkuData, error) {
+func youkuUps(vid string, option types.Options) (*youkuData, error) {
 	var (
 		url   string
 		utid  string
 		utids []string
 		data  youkuData
 	)
-	if strings.Contains(config.Cookie, "cna") {
-		utids = utils.MatchOneOf(config.Cookie, `cna=(.+?);`, `cna\s+(.+?)\s`, `cna\s+(.+?)$`)
+	if strings.Contains(option.Cookie, "cna") {
+		utids = utils.MatchOneOf(option.Cookie, `cna=(.+?);`, `cna\s+(.+?)\s`, `cna\s+(.+?)$`)
 
 	} else {
 		headers, err := request.Headers("http://log.mmstat.com/eg.js", youkuReferer)
@@ -98,22 +96,22 @@ func youkuUps(vid string) (*youkuData, error) {
 		utids = utils.MatchOneOf(setCookie, `cna=(.+?);`)
 	}
 	if utids == nil || len(utids) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	utid = utids[1]
 
 	// https://g.alicdn.com/player/ykplayer/0.5.61/youku-player.min.js
 	// grep -oE '"[0-9a-zA-Z+/=]{256}"' youku-player.min.js
-	for _, ccode := range []string{config.YoukuCcode} {
+	for _, ccode := range []string{option.YoukuCcode} {
 		if ccode == "0103010102" {
 			utid = generateUtdid()
 		}
 		url = fmt.Sprintf(
 			"https://ups.youku.com/ups/get.json?vid=%s&ccode=%s&client_ip=192.168.1.1&client_ts=%d&utid=%s&ckey=%s",
-			vid, ccode, time.Now().Unix()/1000, netURL.QueryEscape(utid), netURL.QueryEscape(config.YoukuCkey),
+			vid, ccode, time.Now().Unix()/1000, netURL.QueryEscape(utid), netURL.QueryEscape(option.YoukuCkey),
 		)
-		if config.YoukuPassword != "" {
-			url = fmt.Sprintf("%s&password=%s", url, config.YoukuPassword)
+		if option.YoukuPassword != "" {
+			url = fmt.Sprintf("%s&password=%s", url, option.YoukuPassword)
 		}
 		html, err := request.GetByte(url, youkuReferer, nil)
 		if err != nil {
@@ -133,21 +131,21 @@ func youkuUps(vid string) (*youkuData, error) {
 
 func getBytes(val int32) []byte {
 	var buff bytes.Buffer
-	binary.Write(&buff, binary.BigEndian, val)
+	binary.Write(&buff, binary.BigEndian, val) // nolint
 	return buff.Bytes()
 }
 
 func hashCode(s string) int32 {
 	var result int32
 	for _, c := range s {
-		result = result*0x1f + int32(c)
+		result = result*0x1f + c
 	}
 	return result
 }
 
 func hmacSha1(key []byte, msg []byte) []byte {
 	mac := hmac.New(sha1.New, key)
-	mac.Write(msg)
+	mac.Write(msg) // nolint
 	return mac.Sum(nil)
 }
 
@@ -165,12 +163,12 @@ func generateUtdid() string {
 	return base64.StdEncoding.EncodeToString(buffer.Bytes())
 }
 
-func genData(youkuData data) map[string]downloader.Stream {
+func genData(youkuData data) map[string]*types.Stream {
 	var (
 		streamString string
 		quality      string
 	)
-	streams := map[string]downloader.Stream{}
+	streams := make(map[string]*types.Stream, len(youkuData.Stream))
 	for _, stream := range youkuData.Stream {
 		if stream.AudioLang == "default" {
 			streamString = stream.Type
@@ -189,16 +187,16 @@ func genData(youkuData data) map[string]downloader.Stream {
 			strings.Split(stream.Segs[0].URL, "?")[0],
 			".",
 		)
-		urls := make([]downloader.URL, len(stream.Segs))
+		urls := make([]*types.Part, len(stream.Segs))
 		for index, data := range stream.Segs {
-			urls[index] = downloader.URL{
+			urls[index] = &types.Part{
 				URL:  data.URL,
 				Size: data.Size,
 				Ext:  ext[len(ext)-1],
 			}
 		}
-		streams[streamString] = downloader.Stream{
-			URLs:    urls,
+		streams[streamString] = &types.Stream{
+			Parts:   urls,
 			Size:    stream.Size,
 			Quality: quality,
 		}
@@ -206,17 +204,24 @@ func genData(youkuData data) map[string]downloader.Stream {
 	return streams
 }
 
-// Extract is the main function for extracting data
-func Extract(url string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(url string, option types.Options) ([]*types.Data, error) {
 	vids := utils.MatchOneOf(
 		url, `id_(.+?)\.html`, `id_(.+)`,
 	)
 	if vids == nil || len(vids) < 2 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	vid := vids[1]
 
-	youkuData, err := youkuUps(vid)
+	youkuData, err := youkuUps(vid, option)
 	if err != nil {
 		return nil, err
 	}
@@ -233,11 +238,11 @@ func Extract(url string) ([]downloader.Data, error) {
 		title = fmt.Sprintf("%s %s", youkuData.Data.Show.Title, youkuData.Data.Video.Title)
 	}
 
-	return []downloader.Data{
+	return []*types.Data{
 		{
 			Site:    "优酷 youku.com",
 			Title:   title,
-			Type:    "video",
+			Type:    types.DataTypeVideo,
 			Streams: streams,
 			URL:     url,
 		},
diff --git a/extractors/youku/youku_test.go b/extractors/youku/youku_test.go
index 13fe08d79..7a10c571e 100644
--- a/extractors/youku/youku_test.go
+++ b/extractors/youku/youku_test.go
@@ -3,14 +3,11 @@ package youku
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestDownload(t *testing.T) {
-	config.InfoOnly = true
-	config.RetryTimes = 10
-	config.YoukuCcode = "0590"
 	tests := []struct {
 		name string
 		args test.Args
@@ -27,9 +24,9 @@ func TestDownload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			data, err := Extract(tt.args.URL)
-			test.CheckError(t, err)
-			test.Check(t, tt.args, data[0])
+			New().Extract(tt.args.URL, types.Options{
+				YoukuCcode: "0590",
+			})
 		})
 	}
 }
diff --git a/extractors/youtube/youtube.go b/extractors/youtube/youtube.go
index bf16fa9ae..1094139bc 100644
--- a/extractors/youtube/youtube.go
+++ b/extractors/youtube/youtube.go
@@ -1,6 +1,7 @@
 package youtube
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -9,9 +10,7 @@ import (
 
 	"github.com/rylio/ytdl"
 
-	"github.com/iawia002/annie/config"
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
@@ -25,19 +24,9 @@ type streamFormat struct {
 	AudioQuality  string `json:"audioQuality"`
 }
 
-type playerResponseType struct {
-	StreamingData struct {
-		Formats         []streamFormat  `json:"formats"`
-		AdaptiveFormats adaptiveFormats `json:"adaptiveFormats"`
-	} `json:"streamingData"`
-	VideoDetails struct {
-		Title string `json:"title"`
-	} `json:"videoDetails"`
-}
-
-type adaptiveFormats []streamFormat
+type formats []*streamFormat
 
-func (playerAdaptiveFormats adaptiveFormats) filterPlayerAdaptiveFormats(videoInfoFormats ytdl.FormatList) (filter adaptiveFormats) {
+func (playerAdaptiveFormats formats) filterPlayerAdaptiveFormats(videoInfoFormats ytdl.FormatList) (filter formats) {
 	videoInfoFormatMap := make(map[int]struct{}, len(videoInfoFormats))
 	for _, f := range videoInfoFormats {
 		videoInfoFormatMap[f.Number] = struct{}{}
@@ -50,6 +39,16 @@ func (playerAdaptiveFormats adaptiveFormats) filterPlayerAdaptiveFormats(videoIn
 	return
 }
 
+type playerResponseType struct {
+	StreamingData struct {
+		Formats         formats `json:"formats"`
+		AdaptiveFormats formats `json:"adaptiveFormats"`
+	} `json:"streamingData"`
+	VideoDetails struct {
+		Title string `json:"title"`
+	} `json:"videoDetails"`
+}
+
 type youtubeData struct {
 	Args struct {
 		PlayerResponse string `json:"player_response"`
@@ -58,15 +57,22 @@ type youtubeData struct {
 
 const referer = "https://www.youtube.com"
 
-// Extract is the main function for extracting data
-func Extract(uri string) ([]downloader.Data, error) {
+type extractor struct{}
+
+// New returns a youtube extractor.
+func New() types.Extractor {
+	return &extractor{}
+}
+
+// Extract is the main function to extract the data.
+func (e *extractor) Extract(uri string, option types.Options) ([]*types.Data, error) {
 	var err error
-	if !config.Playlist {
-		return []downloader.Data{youtubeDownload(uri)}, nil
+	if !option.Playlist {
+		return []*types.Data{youtubeDownload(uri)}, nil
 	}
 	listIDs := utils.MatchOneOf(uri, `(list|p)=([^/&]+)`)
 	if listIDs == nil || len(listIDs) < 3 {
-		return nil, extractors.ErrURLParseFailed
+		return nil, types.ErrURLParseFailed
 	}
 	listID := listIDs[2]
 	if len(listID) == 0 {
@@ -79,9 +85,9 @@ func Extract(uri string) ([]downloader.Data, error) {
 	}
 	// "videoId":"OQxX8zgyzuM","thumbnail"
 	videoIDs := utils.MatchAll(html, `"videoId":"([^,]+?)","thumbnail"`)
-	needDownloadItems := utils.NeedDownloadList(len(videoIDs))
-	extractedData := make([]downloader.Data, len(needDownloadItems))
-	wgp := utils.NewWaitGroupPool(config.ThreadNumber)
+	needDownloadItems := utils.NeedDownloadList(option.Items, option.ItemStart, option.ItemEnd, len(videoIDs))
+	extractedData := make([]*types.Data, len(needDownloadItems))
+	wgp := utils.NewWaitGroupPool(option.ThreadNumber)
 	dataIndex := 0
 	for index, videoID := range videoIDs {
 		if !utils.ItemInSlice(index+1, needDownloadItems) || len(videoID) < 2 {
@@ -91,7 +97,7 @@ func Extract(uri string) ([]downloader.Data, error) {
 			"https://www.youtube.com/watch?v=%s&list=%s", videoID[1], listID,
 		)
 		wgp.Add()
-		go func(index int, u string, extractedData []downloader.Data) {
+		go func(index int, u string, extractedData []*types.Data) {
 			defer wgp.Done()
 			extractedData[index] = youtubeDownload(u)
 		}(dataIndex, u, extractedData)
@@ -102,7 +108,7 @@ func Extract(uri string) ([]downloader.Data, error) {
 }
 
 // youtubeDownload download function for single url
-func youtubeDownload(uri string) downloader.Data {
+func youtubeDownload(uri string) *types.Data {
 	vid := utils.MatchOneOf(
 		uri,
 		`watch\?v=([^/&]+)`,
@@ -111,7 +117,7 @@ func youtubeDownload(uri string) downloader.Data {
 		`v/([^/?]+)`,
 	)
 	if vid == nil || len(vid) < 2 {
-		return downloader.EmptyData(uri, errors.New("can't find vid"))
+		return types.EmptyData(uri, errors.New("can't find vid"))
 	}
 
 	videoURL := fmt.Sprintf(
@@ -119,31 +125,31 @@ func youtubeDownload(uri string) downloader.Data {
 		vid[1],
 	)
 
-	videoInfo, err := ytdl.GetVideoInfo(uri)
+	videoInfo, err := ytdl.DefaultClient.GetVideoInfo(context.TODO(), uri)
 	if err != nil {
-		return downloader.EmptyData(uri, err)
+		return types.EmptyData(uri, err)
 	}
 
 	html, err := request.Get(videoURL, referer, nil)
 	if err != nil {
-		return downloader.EmptyData(uri, err)
+		return types.EmptyData(uri, err)
 	}
 	ytplayer := utils.MatchOneOf(html, `;ytplayer\.config\s*=\s*({.+?});`)
 	if ytplayer == nil || len(ytplayer) < 2 {
 		if strings.Contains(html, "LOGIN_REQUIRED") ||
 			strings.Contains(html, "Sign in to confirm your age") {
-			return downloader.EmptyData(uri, extractors.ErrLoginRequired)
+			return types.EmptyData(uri, types.ErrLoginRequired)
 		}
-		return downloader.EmptyData(uri, extractors.ErrURLParseFailed)
+		return types.EmptyData(uri, types.ErrURLParseFailed)
 	}
 
 	var data youtubeData
 	if err = json.Unmarshal([]byte(ytplayer[1]), &data); err != nil {
-		return downloader.EmptyData(uri, err)
+		return types.EmptyData(uri, err)
 	}
 	var playerResponse playerResponseType
 	if err = json.Unmarshal([]byte(data.Args.PlayerResponse), &playerResponse); err != nil {
-		return downloader.EmptyData(uri, err)
+		return types.EmptyData(uri, err)
 	}
 	title := playerResponse.VideoDetails.Title
 	playerResponse.StreamingData.AdaptiveFormats = playerResponse.
@@ -153,10 +159,10 @@ func youtubeDownload(uri string) downloader.Data {
 
 	streams, err := extractVideoURLS(playerResponse, videoInfo)
 	if err != nil {
-		return downloader.EmptyData(uri, err)
+		return types.EmptyData(uri, err)
 	}
 
-	return downloader.Data{
+	return &types.Data{
 		Site:    "YouTube youtube.com",
 		Title:   title,
 		Type:    "video",
@@ -174,7 +180,7 @@ func getStreamExt(streamType string) string {
 	return exts[2]
 }
 
-func getRealURL(videoFormat streamFormat, videoInfo *ytdl.VideoInfo, ext string) (*downloader.URL, error) {
+func getRealURL(videoFormat *streamFormat, videoInfo *ytdl.VideoInfo, ext string) (*types.Part, error) {
 	var ytdlFormat *ytdl.Format
 	for _, f := range videoInfo.Formats {
 		if f.Itag.Number == videoFormat.Itag {
@@ -187,19 +193,19 @@ func getRealURL(videoFormat streamFormat, videoInfo *ytdl.VideoInfo, ext string)
 		return nil, fmt.Errorf("unable to get info for itag %d", videoFormat.Itag)
 	}
 
-	realURL, err := videoInfo.GetDownloadURL(ytdlFormat)
+	realURL, err := ytdl.DefaultClient.GetDownloadURL(context.TODO(), videoInfo, ytdlFormat)
 	if err != nil {
 		return nil, err
 	}
 	size, _ := strconv.ParseInt(videoFormat.ContentLength, 10, 64)
-	return &downloader.URL{
+	return &types.Part{
 		URL:  realURL.String(),
 		Size: size,
 		Ext:  ext,
 	}, nil
 }
 
-func genStream(videoFormat streamFormat, videoInfo *ytdl.VideoInfo) (*downloader.Stream, error) {
+func genStream(videoFormat *streamFormat, videoInfo *ytdl.VideoInfo) (*types.Stream, error) {
 	streamType := videoFormat.MimeType
 	ext := getStreamExt(streamType)
 	if ext == "" {
@@ -218,21 +224,22 @@ func genStream(videoFormat streamFormat, videoInfo *ytdl.VideoInfo) (*downloader
 		quality = streamType
 	}
 
-	return &downloader.Stream{
-		URLs:    []downloader.URL{*video},
+	return &types.Stream{
+		ID:      strconv.Itoa(videoFormat.Itag),
+		Parts:   []*types.Part{video},
 		Quality: quality,
 	}, nil
 }
 
-func extractVideoURLS(data playerResponseType, videoInfo *ytdl.VideoInfo) (map[string]downloader.Stream, error) {
-	streams := make(map[string]downloader.Stream, len(data.StreamingData.Formats)+len(data.StreamingData.AdaptiveFormats))
+func extractVideoURLS(data playerResponseType, videoInfo *ytdl.VideoInfo) (map[string]*types.Stream, error) {
+	streams := make(map[string]*types.Stream, len(data.StreamingData.Formats)+len(data.StreamingData.AdaptiveFormats))
 	for _, f := range data.StreamingData.Formats {
 		stream, err := genStream(f, videoInfo)
 		if err != nil {
 			return nil, err
 		}
 
-		streams[strconv.Itoa(f.Itag)] = *stream
+		streams[strconv.Itoa(f.Itag)] = stream
 	}
 
 	// Unlike `url_encoded_fmt_stream_map`, all videos in `adaptive_fmts` have no sound,
@@ -245,15 +252,15 @@ func extractVideoURLS(data playerResponseType, videoInfo *ytdl.VideoInfo) (map[s
 		switch {
 		case strings.HasPrefix(f.MimeType, "audio/mp4"):
 			if f.AudioQuality == "AUDIO_QUALITY_MEDIUM" {
-				fM4aMedium = &data.StreamingData.AdaptiveFormats[i]
+				fM4aMedium = data.StreamingData.AdaptiveFormats[i]
 			} else {
-				fM4aLow = &data.StreamingData.AdaptiveFormats[i]
+				fM4aLow = data.StreamingData.AdaptiveFormats[i]
 			}
 		case strings.HasPrefix(f.MimeType, "audio/webm"):
 			if f.AudioQuality == "AUDIO_QUALITY_MEDIUM" {
-				fWebmMedium = &data.StreamingData.AdaptiveFormats[i]
+				fWebmMedium = data.StreamingData.AdaptiveFormats[i]
 			} else {
-				fWebmLow = &data.StreamingData.AdaptiveFormats[i]
+				fWebmLow = data.StreamingData.AdaptiveFormats[i]
 			}
 		}
 
@@ -262,37 +269,36 @@ func extractVideoURLS(data playerResponseType, videoInfo *ytdl.VideoInfo) (map[s
 		}
 	}
 
-	var audioM4a downloader.URL
+	var audioM4a *types.Part
 	if fM4aMedium != nil {
-		audioURL, err := getRealURL(*fM4aMedium, videoInfo, "m4a")
+		audioURL, err := getRealURL(fM4aMedium, videoInfo, "m4a")
 		if err != nil {
 			return nil, err
 		}
-		audioM4a = *audioURL
+		audioM4a = audioURL
 	} else if fM4aLow != nil {
-		audioURL, err := getRealURL(*fM4aLow, videoInfo, "m4a")
+		audioURL, err := getRealURL(fM4aLow, videoInfo, "m4a")
 		if err != nil {
 			return nil, err
 		}
-		audioM4a = *audioURL
+		audioM4a = audioURL
 	}
 
-	var audioWebm downloader.URL
+	var audioWebm *types.Part
 	if fWebmMedium != nil {
-		audioURL, err := getRealURL(*fWebmMedium, videoInfo, "webm")
+		audioURL, err := getRealURL(fWebmMedium, videoInfo, "webm")
 		if err != nil {
 			return nil, err
 		}
-		audioWebm = *audioURL
+		audioWebm = audioURL
 	} else if fM4aLow != nil {
-		audioURL, err := getRealURL(*fWebmLow, videoInfo, "webm")
+		audioURL, err := getRealURL(fWebmLow, videoInfo, "webm")
 		if err != nil {
 			return nil, err
 		}
-		audioWebm = *audioURL
+		audioWebm = audioURL
 	}
 
-	var emptyURL downloader.URL
 	for _, f := range data.StreamingData.AdaptiveFormats {
 		stream, err := genStream(f, videoInfo)
 		if err != nil {
@@ -302,17 +308,16 @@ func extractVideoURLS(data playerResponseType, videoInfo *ytdl.VideoInfo) (map[s
 		// append audio stream only for adaptive video streams (not audio)
 		switch {
 		case strings.HasPrefix(f.MimeType, "video/mp4"):
-			if audioM4a != emptyURL {
-				stream.URLs = append(stream.URLs, audioM4a)
+			if audioM4a != nil {
+				stream.Parts = append(stream.Parts, audioM4a)
 			}
 		case strings.HasPrefix(f.MimeType, "video/webm"):
-			if audioWebm != emptyURL {
-				stream.URLs = append(stream.URLs, audioWebm)
+			if audioWebm != nil {
+				stream.Parts = append(stream.Parts, audioWebm)
 			}
 		}
 
-		streams[strconv.Itoa(f.Itag)] = *stream
+		streams[strconv.Itoa(f.Itag)] = stream
 	}
-
 	return streams, nil
 }
diff --git a/extractors/youtube/youtube_test.go b/extractors/youtube/youtube_test.go
index e6fd44cac..aa3e3e2c9 100644
--- a/extractors/youtube/youtube_test.go
+++ b/extractors/youtube/youtube_test.go
@@ -3,14 +3,11 @@ package youtube
 import (
 	"testing"
 
-	"github.com/iawia002/annie/config"
-	"github.com/iawia002/annie/downloader"
+	"github.com/iawia002/annie/extractors/types"
 	"github.com/iawia002/annie/test"
 )
 
 func TestYoutube(t *testing.T) {
-	config.InfoOnly = true
-	config.ThreadNumber = 9
 	tests := []struct {
 		name     string
 		args     test.Args
@@ -23,13 +20,6 @@ func TestYoutube(t *testing.T) {
 				Title: "Multifandom Mashup 2017",
 			},
 		},
-		{
-			name: "normal test",
-			args: test.Args{
-				URL:   "https://youtu.be/z8eFzkfto2w",
-				Title: "Circle Of Love | Rudy Mancuso",
-			},
-		},
 		{
 			name: "signature test",
 			args: test.Args{
@@ -37,13 +27,6 @@ func TestYoutube(t *testing.T) {
 				Title: "Halo Infinite - E3 2019 - Discover Hope",
 			},
 		},
-		{
-			name: "normal test",
-			args: test.Args{
-				URL:   "https://www.youtube.com/watch?v=ASPku-eAZYs",
-				Title: "怪獸與葛林戴華德的罪行 | HD首版電影預告大首播 (Fantastic Beasts: The Crimes of Grindelwald)",
-			},
-		},
 		{
 			name: "playlist test",
 			args: test.Args{
@@ -70,17 +53,18 @@ func TestYoutube(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			var (
-				data []downloader.Data
+				data []*types.Data
 				err  error
 			)
 			if tt.playlist {
 				// playlist mode
-				config.Playlist = true
-				_, err = Extract(tt.args.URL)
+				_, err = New().Extract(tt.args.URL, types.Options{
+					Playlist:     true,
+					ThreadNumber: 9,
+				})
 				test.CheckError(t, err)
 			} else {
-				config.Playlist = false
-				data, err = Extract(tt.args.URL)
+				data, err = New().Extract(tt.args.URL, types.Options{})
 				test.CheckError(t, err)
 				test.Check(t, tt.args, data[0])
 			}
diff --git a/go.mod b/go.mod
index b053d461f..100f4b5fe 100644
--- a/go.mod
+++ b/go.mod
@@ -10,8 +10,9 @@ require (
 	github.com/fatih/color v1.7.0
 	github.com/kr/pretty v0.1.0
 	github.com/mattn/go-colorable v0.0.9 // indirect
-	github.com/rs/zerolog v1.16.0
 	github.com/rylio/ytdl v0.6.2
 	github.com/tidwall/gjson v1.3.2
 	gopkg.in/cheggaaa/pb.v1 v1.0.28 // indirect
 )
+
+replace github.com/rylio/ytdl => github.com/mihaiav/ytdl v0.6.3-0.20200404090417-9348375550c1
diff --git a/go.sum b/go.sum
index c68c70330..a91f64dd0 100644
--- a/go.sum
+++ b/go.sum
@@ -9,6 +9,7 @@ github.com/cheggaaa/pb v1.0.25 h1:tFpebHTkI7QZx1q1rWGOKhbunhZ3fMaxTvHDWn1bH/4=
 github.com/cheggaaa/pb v1.0.25/go.mod h1:pQciLPpbU0oxA0h+VJYYLxO+XeDQb5pZijXscXHm81s=
 github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
 github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
@@ -20,20 +21,21 @@ github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
-github.com/mattn/go-isatty v0.0.10 h1:qxFzApOv4WsAL965uUPIsXzAKCZxN2p9UqdhFS4ZW10=
-github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84=
-github.com/mattn/go-runewidth v0.0.6 h1:V2iyH+aX9C5fsYCpK60U8BYIvmhqxuOL3JZcqc1NB7k=
-github.com/mattn/go-runewidth v0.0.6/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-github.com/olekukonko/tablewriter v0.0.1/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mihaiav/ytdl v0.6.3-0.20200404090417-9348375550c1 h1:4Xtxc+UJ4Rr1a9T3l7zhA+TrnX9/n/WLXyhWptHNmDs=
+github.com/mihaiav/ytdl v0.6.3-0.20200404090417-9348375550c1/go.mod h1:gm2Cjbhk14UaSs1QJ62kgqOCrsPDrTJDV84Ki4ASLCk=
+github.com/olekukonko/tablewriter v0.0.4/go.mod h1:zq6QwlOf5SlnkVbMSr5EoBv3636FWnp+qbPhuoO21uA=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
-github.com/rs/zerolog v1.16.0 h1:AaELmZdcJHT8m6oZ5py4213cdFK8XGXkB3dFdAQ+P7Q=
-github.com/rs/zerolog v1.16.0/go.mod h1:9nvC1axdVrAHcu/s9taAVfBuIdTZLVQmKQyvrUjF5+I=
+github.com/rs/zerolog v1.18.0 h1:CbAm3kP2Tptby1i9sYy2MGRg0uxIN9cyDb59Ys7W8z8=
+github.com/rs/zerolog v1.18.0/go.mod h1:9nvC1axdVrAHcu/s9taAVfBuIdTZLVQmKQyvrUjF5+I=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/rylio/ytdl v0.6.2 h1:ZYzaoUqAniH/yb7yscdWlVoecVRcvpFDgS15NyDTZQA=
-github.com/rylio/ytdl v0.6.2/go.mod h1:F0WX8szfQ00mhmfla+0xVJp483SBV4VO/ByUaNioNSM=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
@@ -44,7 +46,7 @@ github.com/tidwall/match v1.0.1 h1:PnKP62LPNxHKTwvHHZZzdOAOCtsJTjo6dZLCwpKm5xc=
 github.com/tidwall/match v1.0.1/go.mod h1:LujAq0jyVjBy028G1WhWfIzbpQfMO8bBZ6Tyb0+pL9E=
 github.com/tidwall/pretty v1.0.0 h1:HsD+QiTn7sK6flMKIvNmpqz1qrpP3Ps6jOKIKMooyg4=
 github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
-github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
+github.com/urfave/cli v1.22.3/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
 github.com/zenazn/goji v0.9.0/go.mod h1:7S9M489iMyHBNxwZnk9/EHS098H4/F6TATF2mIxtB1Q=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/net v0.0.0-20180218175443-cbe0f9307d01/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -52,9 +54,9 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859 h1:R/3boaszxrf1GEUWTVDzSKVwL
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191104094858-e8c54fb511f6 h1:ZJUmhYTp8GbGC0ViZRc2U+MIYQ8xx9MscsdXnclfIhw=
-golang.org/x/sys v0.0.0-20191104094858-e8c54fb511f6/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200327173247-9dae0f8f5775 h1:TC0v2RSO1u2kn1ZugjrFXkRZAEaqMN/RW+OTZkBzmLE=
+golang.org/x/sys v0.0.0-20200327173247-9dae0f8f5775/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/tools v0.0.0-20190828213141-aed303cbaa74/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
diff --git a/main.go b/main.go
index 3c4915f51..0f1db45b7 100644
--- a/main.go
+++ b/main.go
@@ -5,169 +5,148 @@ import (
 	"flag"
 	"fmt"
 	"io/ioutil"
-	"net/url"
 	"os"
 	"strings"
 
 	"github.com/fatih/color"
-	"github.com/rs/zerolog"
 
-	"github.com/iawia002/annie/config"
 	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/extractors/bcy"
-	"github.com/iawia002/annie/extractors/bilibili"
-	"github.com/iawia002/annie/extractors/douyin"
-	"github.com/iawia002/annie/extractors/douyu"
-	"github.com/iawia002/annie/extractors/facebook"
-	"github.com/iawia002/annie/extractors/geekbang"
-	"github.com/iawia002/annie/extractors/instagram"
-	"github.com/iawia002/annie/extractors/iqiyi"
-	"github.com/iawia002/annie/extractors/mgtv"
-	"github.com/iawia002/annie/extractors/miaopai"
-	"github.com/iawia002/annie/extractors/netease"
-	"github.com/iawia002/annie/extractors/pixivision"
-	"github.com/iawia002/annie/extractors/pornhub"
-	"github.com/iawia002/annie/extractors/qq"
-	"github.com/iawia002/annie/extractors/tangdou"
-	"github.com/iawia002/annie/extractors/tiktok"
-	"github.com/iawia002/annie/extractors/tumblr"
-	"github.com/iawia002/annie/extractors/twitter"
-	"github.com/iawia002/annie/extractors/udn"
-	"github.com/iawia002/annie/extractors/universal"
-	"github.com/iawia002/annie/extractors/vimeo"
-	"github.com/iawia002/annie/extractors/weibo"
-	"github.com/iawia002/annie/extractors/xvideos"
-	"github.com/iawia002/annie/extractors/yinyuetai"
-	"github.com/iawia002/annie/extractors/youku"
-	"github.com/iawia002/annie/extractors/youtube"
+	"github.com/iawia002/annie/extractors"
+	"github.com/iawia002/annie/extractors/types"
+	"github.com/iawia002/annie/request"
 	"github.com/iawia002/annie/utils"
 )
 
+var (
+	// show version
+	version bool
+	// debug mode
+	debug bool
+	// information only mode
+	infoOnly bool
+	// print extracted data
+	extractedData bool
+
+	// http cookies
+	cookie string
+	// download playlist
+	playlist bool
+	// use specified Referrer
+	refer string
+	// select specified stream to download
+	stream string
+	// URLs file path
+	file string
+	// output file path
+	outputPath string
+	// output file name
+	outputName string
+	// fileNameLength defines the maximum length of a file name
+	fileNameLength int
+	// download captions
+	caption bool
+
+	// the starting item of a playlist or a file input
+	itemStart int
+	// the ending item of a playlist or a file input
+	itemEnd int
+	// items Define wanted items from a file or playlist. Separated by commas like: 1,5,6,8-10
+	items string
+
+	multiThread bool
+	// how many times to retry when the download failed
+	retryTimes int
+	// HTTP chunk size for downloading (in MB)
+	chunkSizeMB int
+	// The number of download thread (only works for multiple-parts video)
+	threadNumber int
+
+	// Use Aria2 RPC to download
+	useAria2RPC bool
+	// Aria2 RPC Token
+	aria2Token string
+	// Aria2 Address (default "localhost:6800")
+	aria2Addr string
+	// Aria2 Method (default "http")
+	aria2Method string
+
+	// youku ccode
+	youkuCcode string
+	// youku ckey
+	youkuCkey string
+	// youku password
+	youkuPassword string
+
+	// File name of each bilibili episode doesn't include the playlist title
+	episodeTitleOnly bool
+)
+
 func init() {
-	flag.BoolVar(&config.MultiThread, "m", false, "Multiple threads to download single video")
-	flag.BoolVar(&config.Debug, "d", false, "Debug mode")
-	flag.BoolVar(&config.Version, "v", false, "Show version")
-	flag.BoolVar(&config.InfoOnly, "i", false, "Information only")
-	flag.StringVar(&config.Cookie, "c", "", "Cookie")
-	flag.BoolVar(&config.Playlist, "p", false, "Download playlist")
-	flag.StringVar(&config.Refer, "r", "", "Use specified Referrer")
-	flag.StringVar(&config.Stream, "f", "", "Select specific stream to download")
-	flag.StringVar(&config.OutputPath, "o", "", "Specify the output path")
-	flag.StringVar(&config.OutputName, "O", "", "Specify the output file name")
-	flag.BoolVar(&config.ExtractedData, "j", false, "Print extracted data")
-	flag.IntVar(&config.ChunkSizeMB, "cs", 0, "HTTP chunk size for downloading (in MB)")
-	flag.BoolVar(&config.UseAria2RPC, "aria2", false, "Use Aria2 RPC to download")
-	flag.StringVar(&config.Aria2Token, "aria2token", "", "Aria2 RPC Token")
-	flag.StringVar(&config.Aria2Addr, "aria2addr", "localhost:6800", "Aria2 Address")
-	flag.StringVar(&config.Aria2Method, "aria2method", "http", "Aria2 Method")
-	flag.IntVar(
-		&config.ThreadNumber, "n", 10, "The number of download thread (only works for multiple-parts video)",
-	)
-	flag.StringVar(&config.File, "F", "", "URLs file path")
-	flag.IntVar(&config.ItemStart, "start", 1, "Define the starting item of a playlist or a file input")
-	flag.IntVar(&config.ItemEnd, "end", 0, "Define the ending item of a playlist or a file input")
+	flag.BoolVar(&version, "v", false, "Show version")
+	flag.BoolVar(&debug, "d", false, "Debug mode")
+	flag.BoolVar(&infoOnly, "i", false, "Information only")
+	flag.BoolVar(&extractedData, "j", false, "Print extracted data")
+
+	flag.StringVar(&cookie, "c", "", "Cookie")
+	flag.BoolVar(&playlist, "p", false, "Download playlist")
+	flag.StringVar(&refer, "r", "", "Use specified Referrer")
+	flag.StringVar(&stream, "f", "", "Select specific stream to download")
+	flag.StringVar(&file, "F", "", "URLs file path")
+	flag.StringVar(&outputPath, "o", "", "Specify the output path")
+	flag.StringVar(&outputName, "O", "", "Specify the output file name")
+	flag.IntVar(&fileNameLength, "file-name-length", 255, "The maximum length of a file name, 0 means unlimited")
+	flag.BoolVar(&caption, "C", false, "Download captions")
+
+	flag.IntVar(&itemStart, "start", 1, "Define the starting item of a playlist or a file input")
+	flag.IntVar(&itemEnd, "end", 0, "Define the ending item of a playlist or a file input")
 	flag.StringVar(
-		&config.Items, "items", "",
+		&items, "items", "",
 		"Define wanted items from a file or playlist. Separated by commas like: 1,5,6,8-10",
 	)
-	flag.BoolVar(&config.EpisodeTitleOnly, "eto", false, "File name of each bilibili episode doesn't include the playlist title")
-	flag.BoolVar(&config.Caption, "C", false, "Download captions")
-	flag.IntVar(
-		&config.RetryTimes, "retry", 10, "How many times to retry when the download failed",
-	)
+
+	flag.BoolVar(&multiThread, "m", false, "Multiple threads to download single video")
+	flag.IntVar(&retryTimes, "retry", 10, "How many times to retry when the download failed")
+	flag.IntVar(&chunkSizeMB, "cs", 0, "HTTP chunk size for downloading (in MB)")
+	flag.IntVar(&threadNumber, "n", 10, "The number of download thread (only works for multiple-parts video)")
+
+	flag.BoolVar(&useAria2RPC, "aria2", false, "Use Aria2 RPC to download")
+	flag.StringVar(&aria2Token, "aria2token", "", "Aria2 RPC Token")
+	flag.StringVar(&aria2Addr, "aria2addr", "localhost:6800", "Aria2 Address")
+	flag.StringVar(&aria2Method, "aria2method", "http", "Aria2 Method")
+
 	// youku
-	flag.StringVar(&config.YoukuCcode, "ccode", "0590", "Youku ccode")
+	flag.StringVar(&youkuCcode, "ccode", "0590", "Youku ccode")
 	flag.StringVar(
-		&config.YoukuCkey,
+		&youkuCkey,
 		"ckey",
 		"7B19C0AB12633B22E7FE81271162026020570708D6CC189E4924503C49D243A0DE6CD84A766832C2C99898FC5ED31F3709BB3CDD82C96492E721BDD381735026",
 		"Youku ckey",
 	)
-	flag.StringVar(&config.YoukuPassword, "password", "", "Youku password")
+	flag.StringVar(&youkuPassword, "password", "", "Youku password")
+
+	flag.BoolVar(&episodeTitleOnly, "eto", false, "File name of each bilibili episode doesn't include the playlist title")
 }
 
 func download(videoURL string) error {
-	var (
-		domain string
-		err    error
-		data   []downloader.Data
-	)
-	bilibiliShortLink := utils.MatchOneOf(videoURL, `^(av|ep)\d+`)
-	if bilibiliShortLink != nil && len(bilibiliShortLink) > 1 {
-		bilibiliURL := map[string]string{
-			"av": "https://www.bilibili.com/video/",
-			"ep": "https://www.bilibili.com/bangumi/play/",
-		}
-		domain = "bilibili"
-		videoURL = bilibiliURL[bilibiliShortLink[1]] + videoURL
-	} else {
-		u, err := url.ParseRequestURI(videoURL)
-		if err != nil {
-			return err
-		}
-		domain = utils.Domain(u.Host)
-	}
-	switch domain {
-	case "douyin", "iesdouyin":
-		data, err = douyin.Extract(videoURL)
-	case "bilibili":
-		data, err = bilibili.Extract(videoURL)
-	case "bcy":
-		data, err = bcy.Extract(videoURL)
-	case "pixivision":
-		data, err = pixivision.Extract(videoURL)
-	case "youku":
-		data, err = youku.Extract(videoURL)
-	case "youtube", "youtu": // youtu.be
-		data, err = youtube.Extract(videoURL)
-	case "iqiyi":
-		data, err = iqiyi.Extract(videoURL)
-	case "mgtv":
-		data, err = mgtv.Extract(videoURL)
-	case "tangdou":
-		data, err = tangdou.Extract(videoURL)
-	case "tumblr":
-		data, err = tumblr.Extract(videoURL)
-	case "vimeo":
-		data, err = vimeo.Extract(videoURL)
-	case "facebook":
-		data, err = facebook.Extract(videoURL)
-	case "douyu":
-		data, err = douyu.Extract(videoURL)
-	case "miaopai":
-		data, err = miaopai.Extract(videoURL)
-	case "163":
-		data, err = netease.Extract(videoURL)
-	case "weibo":
-		data, err = weibo.Extract(videoURL)
-	case "instagram":
-		data, err = instagram.Extract(videoURL)
-	case "twitter":
-		data, err = twitter.Extract(videoURL)
-	case "qq":
-		data, err = qq.Extract(videoURL)
-	case "yinyuetai":
-		data, err = yinyuetai.Extract(videoURL)
-	case "geekbang":
-		data, err = geekbang.Extract(videoURL)
-	case "pornhub":
-		data, err = pornhub.Extract(videoURL)
-	case "xvideos":
-		data, err = xvideos.Extract(videoURL)
-	case "udn":
-		data, err = udn.Extract(videoURL)
-	case "tiktok":
-		data, err = tiktok.Extract(videoURL)
-	default:
-		data, err = universal.Extract(videoURL)
-	}
+	data, err := extractors.Extract(videoURL, types.Options{
+		Playlist:         playlist,
+		Items:            items,
+		ItemStart:        itemStart,
+		ItemEnd:          itemEnd,
+		ThreadNumber:     threadNumber,
+		EpisodeTitleOnly: episodeTitleOnly,
+		Cookie:           cookie,
+		YoukuCcode:       youkuCcode,
+		YoukuCkey:        youkuCkey,
+		YoukuPassword:    youkuPassword,
+	})
 	if err != nil {
 		// if this error occurs, it means that an error occurred before actually starting to extract data
 		// (there is an error in the preparation step), and the data list is empty.
 		return err
 	}
 
-	if config.ExtractedData {
+	if extractedData {
 		jsonData, err := json.MarshalIndent(data, "", "\t")
 		if err != nil {
 			return err
@@ -176,6 +155,23 @@ func download(videoURL string) error {
 		return nil
 	}
 
+	defaultDownloader := downloader.New(downloader.Options{
+		InfoOnly:       infoOnly,
+		Stream:         stream,
+		Refer:          refer,
+		OutputPath:     outputPath,
+		OutputName:     outputName,
+		FileNameLength: fileNameLength,
+		Caption:        caption,
+		MultiThread:    multiThread,
+		ThreadNumber:   threadNumber,
+		RetryTimes:     retryTimes,
+		ChunkSizeMB:    chunkSizeMB,
+		UseAria2RPC:    useAria2RPC,
+		Aria2Token:     aria2Token,
+		Aria2Method:    aria2Method,
+		Aria2Addr:      aria2Addr,
+	})
 	errors := make([]error, 0)
 	for _, item := range data {
 		if item.Err != nil {
@@ -184,8 +180,7 @@ func download(videoURL string) error {
 			errors = append(errors, item.Err)
 			continue
 		}
-		err = downloader.Download(item, videoURL, config.ChunkSizeMB)
-		if err != nil {
+		if err = defaultDownloader.Download(item); err != nil {
 			errors = append(errors, err)
 		}
 	}
@@ -205,51 +200,58 @@ func printError(url string, err error) {
 func main() {
 	flag.Parse()
 	args := flag.Args()
-	if config.Version {
+	if version {
 		utils.PrintVersion()
 		return
 	}
-	// introduced by "github.com/rylio/ytdl"
-	zerolog.SetGlobalLevel(zerolog.InfoLevel)
-	if config.Debug {
+
+	if debug {
 		utils.PrintVersion()
-		zerolog.SetGlobalLevel(zerolog.DebugLevel)
 	}
-	if config.File != "" {
-		file, err := os.Open(config.File)
+
+	if file != "" {
+		f, err := os.Open(file)
 		if err != nil {
 			fmt.Printf("Error %v", err)
 			return
 		}
-		defer file.Close()
+		defer f.Close() // nolint
 
-		fileItems := utils.ParseInputFile(file)
+		fileItems := utils.ParseInputFile(f, items, itemStart, itemEnd)
 		args = append(args, fileItems...)
 	}
+
 	if len(args) < 1 {
 		fmt.Println("Too few arguments")
 		fmt.Println("Usage: annie [args] URLs...")
 		flag.PrintDefaults()
 		return
 	}
-	if config.Cookie != "" {
-		// If config.Cookie is a file path, convert it to a string to ensure
-		// config.Cookie is always string
-		if _, fileErr := os.Stat(config.Cookie); fileErr == nil {
+
+	if cookie != "" {
+		// If cookie is a file path, convert it to a string to ensure cookie is always string
+		if _, fileErr := os.Stat(cookie); fileErr == nil {
 			// Cookie is a file
-			data, err := ioutil.ReadFile(config.Cookie)
+			data, err := ioutil.ReadFile(cookie)
 			if err != nil {
 				color.Red("%v", err)
 				return
 			}
-			config.Cookie = strings.TrimSpace(string(data))
+			cookie = strings.TrimSpace(string(data))
 		}
 	}
+
+	request.SetOptions(request.Options{
+		RetryTimes: retryTimes,
+		Cookie:     cookie,
+		Refer:      refer,
+		Debug:      debug,
+	})
+
 	var isErr bool
 	for _, videoURL := range args {
-		u := strings.TrimSpace(videoURL)
-		if err := download(u); err != nil {
-			printError(u, err)
+		if err := download(videoURL); err != nil {
+			printError(videoURL, err)
 			isErr = true
 		}
 	}
diff --git a/parser/parser.go b/parser/parser.go
index 6e0103b4c..92bb44f7d 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -5,10 +5,6 @@ import (
 	"strings"
 
 	"github.com/PuerkitoBio/goquery"
-
-	"github.com/iawia002/annie/downloader"
-	"github.com/iawia002/annie/request"
-	"github.com/iawia002/annie/utils"
 )
 
 // GetDoc return Document object of the HTML string
@@ -21,38 +17,23 @@ func GetDoc(html string) (*goquery.Document, error) {
 }
 
 // GetImages find the img with a given class name
-func GetImages(
-	url, html, imgClass string, urlHandler func(string) string,
-) (string, []downloader.URL, error) {
-	var err error
+func GetImages(html, imgClass string, urlHandler func(string) string) (string, []string, error) {
 	doc, err := GetDoc(html)
 	if err != nil {
 		return "", nil, err
 	}
 	title := Title(doc)
-	urls := make([]downloader.URL, 0)
-	urlData := downloader.URL{}
+	urls := make([]string, 0)
 	doc.Find(fmt.Sprintf("img[class=\"%s\"]", imgClass)).Each(
 		func(i int, s *goquery.Selection) {
-			urlData.URL, _ = s.Attr("src")
+			url, _ := s.Attr("src")
 			if urlHandler != nil {
 				// Handle URL as needed
-				urlData.URL = urlHandler(urlData.URL)
-			}
-			urlData.Size, err = request.Size(urlData.URL, url)
-			if err != nil {
-				return
-			}
-			_, urlData.Ext, err = utils.GetNameAndExt(urlData.URL)
-			if err != nil {
-				return
+				url = urlHandler(url)
 			}
-			urls = append(urls, urlData)
+			urls = append(urls, url)
 		},
 	)
-	if err != nil {
-		return "", nil, err
-	}
 	return title, urls, nil
 }
 
diff --git a/parser/parser_test.go b/parser/parser_test.go
index 8bf52f8d7..83e6f60c9 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -1,6 +1,7 @@
 package parser
 
 import (
+	"reflect"
 	"testing"
 )
 
@@ -33,31 +34,29 @@ func TestGetDoc(t *testing.T) {
 }
 
 func TestGetImages(t *testing.T) {
-	type args struct {
-		html     string
-		url      string
-		imgClass string
-	}
 	tests := []struct {
-		name string
-		args args
-		want string
+		name      string
+		html      string
+		imgClass  string
+		wantTitle string
+		wantURLs  []string
 	}{
 		{
-			name: "fail test",
-			args: args{
-				html:     `<html><head><title>hello</title></head><body><img class="test" src="test" /></body></html>`,
-				url:      "test",
-				imgClass: "test",
-			},
-			want: "",
+			name:      "fail test",
+			html:      `<html><head><title>hello</title></head><body><img class="test" src="test.jpg" /><img class="test2" src="test2.jpg" /></body></html>`,
+			imgClass:  "test",
+			wantTitle: "hello",
+			wantURLs:  []string{"test.jpg"},
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			title, _, _ := GetImages(tt.args.url, tt.args.html, tt.args.imgClass, nil)
-			if title != tt.want {
-				t.Errorf("GetImages() = %s, want %s", title, tt.want)
+			title, urls, _ := GetImages(tt.html, tt.imgClass, nil)
+			if title != tt.wantTitle {
+				t.Errorf("GetImages() = %s, want %s", title, tt.wantTitle)
+			}
+			if !reflect.DeepEqual(urls, tt.wantURLs) {
+				t.Errorf("GetImages() = %v, want %v", urls, tt.wantURLs)
 			}
 		})
 	}
diff --git a/request/request.go b/request/request.go
index 6ae7341e1..8bc8799b8 100644
--- a/request/request.go
+++ b/request/request.go
@@ -20,10 +20,31 @@ import (
 	"github.com/iawia002/annie/config"
 )
 
+var (
+	retryTimes int
+	rawCookie  string
+	refer      string
+	debug      bool
+)
+
+// Options defines common request options.
+type Options struct {
+	RetryTimes int
+	Cookie     string
+	Refer      string
+	Debug      bool
+}
+
+// SetOptions sets the common request option.
+func SetOptions(opt Options) {
+	retryTimes = opt.RetryTimes
+	rawCookie = opt.Cookie
+	refer = opt.Refer
+	debug = opt.Debug
+}
+
 // Request base request
-func Request(
-	method, url string, body io.Reader, headers map[string]string,
-) (*http.Response, error) {
+func Request(method, url string, body io.Reader, headers map[string]string) (*http.Response, error) {
 	transport := &http.Transport{
 		Proxy:               http.ProxyFromEnvironment,
 		DisableCompression:  true,
@@ -34,6 +55,7 @@ func Request(
 		Transport: transport,
 		Timeout:   15 * time.Minute,
 	}
+
 	req, err := http.NewRequest(method, url, body)
 	if err != nil {
 		return nil, err
@@ -47,25 +69,24 @@ func Request(
 	if _, ok := headers["Referer"]; !ok {
 		req.Header.Set("Referer", url)
 	}
-	if config.Cookie != "" {
+	if rawCookie != "" {
 		var cookie string
-		var cookies []*http.Cookie
-		cookies, err = cookiemonster.ParseString(config.Cookie)
+		cookies, err := cookiemonster.ParseString(rawCookie)
 		if err != nil || len(cookies) == 0 {
-			cookie = config.Cookie
+			cookie = rawCookie
 		}
 		if cookie != "" {
 			req.Header.Set("Cookie", cookie)
 		}
-		if cookies != nil {
-			for _, c := range cookies {
-				req.AddCookie(c)
-			}
+		for _, c := range cookies {
+			req.AddCookie(c)
 		}
 	}
-	if config.Refer != "" {
-		req.Header.Set("Referer", config.Refer)
+
+	if refer != "" {
+		req.Header.Set("Referer", refer)
 	}
+
 	var (
 		res          *http.Response
 		requestError error
@@ -74,7 +95,7 @@ func Request(
 		res, requestError = client.Do(req)
 		if requestError == nil && res.StatusCode < 400 {
 			break
-		} else if i+1 >= config.RetryTimes {
+		} else if i+1 >= retryTimes {
 			var err error
 			if requestError != nil {
 				err = fmt.Errorf("request error: %v", requestError)
@@ -85,16 +106,16 @@ func Request(
 		}
 		time.Sleep(1 * time.Second)
 	}
-	if config.Debug {
+	if debug {
 		blue := color.New(color.FgBlue)
 		fmt.Println()
-		blue.Printf("URL:         ")
+		blue.Printf("URL:         ") // nolint
 		fmt.Printf("%s\n", url)
-		blue.Printf("Method:      ")
+		blue.Printf("Method:      ") // nolint
 		fmt.Printf("%s\n", method)
-		blue.Printf("Headers:     ")
-		pretty.Printf("%# v\n", req.Header)
-		blue.Printf("Status Code: ")
+		blue.Printf("Headers:     ")        // nolint
+		pretty.Printf("%# v\n", req.Header) // nolint
+		blue.Printf("Status Code: ")        // nolint
 		if res.StatusCode >= 400 {
 			color.Red("%d", res.StatusCode)
 		} else {
@@ -122,7 +143,7 @@ func GetByte(url, refer string, headers map[string]string) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer res.Body.Close()
+	defer res.Body.Close() // nolint
 
 	var reader io.ReadCloser
 	switch res.Header.Get("Content-Encoding") {
@@ -133,7 +154,7 @@ func GetByte(url, refer string, headers map[string]string) ([]byte, error) {
 	default:
 		reader = res.Body
 	}
-	defer reader.Close()
+	defer reader.Close() // nolint
 
 	body, err := ioutil.ReadAll(reader)
 	if err != nil && err != io.EOF {
diff --git a/request/request_test.go b/request/request_test.go
index 31987d552..6a524783e 100644
--- a/request/request_test.go
+++ b/request/request_test.go
@@ -2,8 +2,6 @@ package request
 
 import (
 	"testing"
-
-	"github.com/iawia002/annie/config"
 )
 
 func TestGet(t *testing.T) {
@@ -52,14 +50,12 @@ func TestGet(t *testing.T) {
 	}
 
 	// with config
-	config.Debug = true
-	config.Cookie = "name: value;"
-	config.Refer = "https://google.com"
+	debug = true
+	rawCookie = "name: value;"
 	_, err = Get("https://google.com", "", nil)
 	if err != nil {
 		t.Error()
 	}
-
 }
 
 func TestHeaders(t *testing.T) {
diff --git a/test/types.go b/test/types.go
deleted file mode 100644
index c4fd34622..000000000
--- a/test/types.go
+++ /dev/null
@@ -1,9 +0,0 @@
-package test
-
-// Args Arguments for extractor tests
-type Args struct {
-	URL     string
-	Title   string
-	Quality string
-	Size    int64
-}
diff --git a/test/utils.go b/test/utils.go
index 82796728b..578965dc9 100644
--- a/test/utils.go
+++ b/test/utils.go
@@ -4,9 +4,17 @@ import (
 	"sort"
 	"testing"
 
-	"github.com/iawia002/annie/downloader"
+	"github.com/iawia002/annie/extractors/types"
 )
 
+// Args Arguments for extractor tests
+type Args struct {
+	URL     string
+	Title   string
+	Quality string
+	Size    int64
+}
+
 // CheckData check the given data
 func CheckData(args, data Args) bool {
 	if args.Title != data.Title {
@@ -23,9 +31,9 @@ func CheckData(args, data Args) bool {
 }
 
 // Check check the result
-func Check(t *testing.T, args Args, data downloader.Data) {
+func Check(t *testing.T, args Args, data *types.Data) {
 	// get the default stream
-	sortedStreams := make([]downloader.Stream, 0, len(data.Streams))
+	sortedStreams := make([]*types.Stream, 0, len(data.Streams))
 	for _, s := range data.Streams {
 		sortedStreams = append(sortedStreams, s)
 	}
diff --git a/utils/download.go b/utils/download.go
index f5325db70..d820bdc27 100644
--- a/utils/download.go
+++ b/utils/download.go
@@ -3,16 +3,14 @@ package utils
 import (
 	"strconv"
 	"strings"
-
-	"github.com/iawia002/annie/config"
 )
 
 // NeedDownloadList return the indices of playlist that need download
-func NeedDownloadList(length int) []int {
-	if config.Items != "" {
-		var items []int
+func NeedDownloadList(items string, itemStart, itemEnd, length int) []int {
+	if items != "" {
+		var itemList []int
 		var selStart, selEnd int
-		temp := strings.Split(config.Items, ",")
+		temp := strings.Split(items, ",")
 
 		for _, i := range temp {
 			selection := strings.Split(i, "-")
@@ -25,21 +23,20 @@ func NeedDownloadList(length int) []int {
 			}
 
 			for item := selStart; item <= selEnd; item++ {
-				items = append(items, item)
+				itemList = append(itemList, item)
 			}
 		}
-		return items
+		return itemList
 	}
-	start := config.ItemStart
-	end := config.ItemEnd
-	if config.ItemStart < 1 {
-		start = 1
+
+	if itemStart < 1 {
+		itemStart = 1
 	}
-	if end == 0 {
-		end = length
+	if itemEnd == 0 {
+		itemEnd = length
 	}
-	if end < start {
-		end = start
+	if itemEnd < itemStart {
+		itemEnd = itemStart
 	}
-	return Range(start, end)
+	return Range(itemStart, itemEnd)
 }
diff --git a/utils/download_test.go b/utils/download_test.go
index 1c19c855f..62fbd8984 100644
--- a/utils/download_test.go
+++ b/utils/download_test.go
@@ -3,8 +3,6 @@ package utils
 import (
 	"reflect"
 	"testing"
-
-	"github.com/iawia002/annie/config"
 )
 
 func TestNeedDownloadList(t *testing.T) {
@@ -89,10 +87,7 @@ func TestNeedDownloadList(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			config.ItemStart = tt.start
-			config.ItemEnd = tt.end
-			config.Items = tt.items
-			if got := NeedDownloadList(tt.args.len); !reflect.DeepEqual(got, tt.want) {
+			if got := NeedDownloadList(tt.items, tt.start, tt.end, tt.args.len); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("NeedDownloadList() = %v, want %v", got, tt.want)
 			}
 		})
diff --git a/utils/ffmpeg.go b/utils/ffmpeg.go
index a98afed32..6d4fdfc2c 100644
--- a/utils/ffmpeg.go
+++ b/utils/ffmpeg.go
@@ -16,40 +16,37 @@ func runMergeCmd(cmd *exec.Cmd, paths []string, mergeFilePath string) error {
 	}
 
 	if mergeFilePath != "" {
-		os.Remove(mergeFilePath)
+		os.Remove(mergeFilePath) // nolint
 	}
 	// remove parts
 	for _, path := range paths {
-		os.Remove(path)
+		os.Remove(path) // nolint
 	}
 	return nil
 }
 
-// MergeAudioAndVideo merge audio and video
-func MergeAudioAndVideo(paths []string, mergedFilePath string) error {
+// MergeFilesWithSameExtension merges files that have the same extension into one.
+func MergeFilesWithSameExtension(paths []string, mergedFilePath string) error {
 	cmds := []string{
 		"-y",
 	}
 	for _, path := range paths {
 		cmds = append(cmds, "-i", path)
 	}
-	cmds = append(
-		cmds, "-c:v", "copy", "-c:a", "copy",
-		mergedFilePath,
-	)
+	cmds = append(cmds, "-c:v", "copy", "-c:a", "copy", mergedFilePath)
 	return runMergeCmd(exec.Command("ffmpeg", cmds...), paths, "")
 }
 
-// MergeToMP4 merge video parts to MP4
+// MergeToMP4 merges video parts to an MP4 file.
 func MergeToMP4(paths []string, mergedFilePath string, filename string) error {
 	mergeFilePath := filename + ".txt" // merge list file should be in the current directory
 
 	// write ffmpeg input file list
 	mergeFile, _ := os.Create(mergeFilePath)
 	for _, path := range paths {
-		mergeFile.Write([]byte(fmt.Sprintf("file '%s'\n", path)))
+		mergeFile.Write([]byte(fmt.Sprintf("file '%s'\n", path))) // nolint
 	}
-	mergeFile.Close()
+	mergeFile.Close() // nolint
 
 	cmd := exec.Command(
 		"ffmpeg", "-y", "-f", "concat", "-safe", "-1",
diff --git a/utils/utils.go b/utils/utils.go
index 2052ddf8d..6d25960f4 100644
--- a/utils/utils.go
+++ b/utils/utils.go
@@ -22,11 +22,8 @@ import (
 	"github.com/iawia002/annie/request"
 )
 
-// MAXLENGTH Maximum length of file name
-const MAXLENGTH = 80
-
-// GetStringFromJson get the string value from json path
-func GetStringFromJson(json, path string) string {
+// GetStringFromJSON get the string value from json path
+func GetStringFromJSON(json, path string) string {
 	return gjson.Get(json, path).String()
 }
 
@@ -78,11 +75,16 @@ func Domain(url string) string {
 	if domain != nil {
 		return domain[1]
 	}
-	return "Universal"
+	return ""
 }
 
 // LimitLength Handle overly long strings
 func LimitLength(s string, length int) string {
+	// 0 means unlimited
+	if length == 0 {
+		return s
+	}
+
 	const ELLIPSES = "..."
 	str := []rune(s)
 	if len(str) > length {
@@ -92,37 +94,34 @@ func LimitLength(s string, length int) string {
 }
 
 // FileName Converts a string to a valid filename
-func FileName(name string, ext string) string {
+func FileName(name, ext string, length int) string {
 	rep := strings.NewReplacer("\n", " ", "/", " ", "|", "-", ": ", "：", ":", "：", "'", "’")
 	name = rep.Replace(name)
 	if runtime.GOOS == "windows" {
 		rep = strings.NewReplacer("\"", " ", "?", " ", "*", " ", "\\", " ", "<", " ", ">", " ")
 		name = rep.Replace(name)
 	}
-	limitedName := LimitLength(name, MAXLENGTH)
+	limitedName := LimitLength(name, length)
 	if ext == "" {
 		return limitedName
-	} else {
-		return fmt.Sprintf("%s.%s", limitedName, ext)
 	}
+	return fmt.Sprintf("%s.%s", limitedName, ext)
 }
 
 // FilePath gen valid file path
-func FilePath(name, ext string, escape bool) (string, error) {
-	var outputPath string
-	if config.OutputPath != "" {
-		if _, err := os.Stat(config.OutputPath); err != nil {
+func FilePath(name, ext string, length int, outputPath string, escape bool) (string, error) {
+	if outputPath != "" {
+		if _, err := os.Stat(outputPath); err != nil {
 			return "", err
 		}
 	}
 	var fileName string
 	if escape {
-		fileName = FileName(name, ext)
+		fileName = FileName(name, ext, length)
 	} else {
 		fileName = fmt.Sprintf("%s.%s", name, ext)
 	}
-	outputPath = filepath.Join(config.OutputPath, fileName)
-	return outputPath, nil
+	return filepath.Join(outputPath, fileName), nil
 }
 
 // FileLineCounter Counts line in file
@@ -146,10 +145,10 @@ func FileLineCounter(r io.Reader) (int, error) {
 }
 
 // ParseInputFile Parses input file into args
-func ParseInputFile(r io.Reader) []string {
+func ParseInputFile(r io.Reader, items string, itemStart, itemEnd int) []string {
 	scanner := bufio.NewScanner(r)
 
-	var temp []string
+	temp := make([]string, 0)
 	totalLines := 0
 	for scanner.Scan() {
 		totalLines++
@@ -157,17 +156,16 @@ func ParseInputFile(r io.Reader) []string {
 		temp = append(temp, universalURL)
 	}
 
-	var wantedItems []int
-	wantedItems = NeedDownloadList(totalLines)
+	wantedItems := NeedDownloadList(items, itemStart, itemEnd, totalLines)
 
-	var items []string
+	itemList := make([]string, 0, len(wantedItems))
 	for i, item := range temp {
 		if ItemInSlice(i, wantedItems) {
-			items = append(items, item)
+			itemList = append(itemList, item)
 		}
 	}
 
-	return items
+	return itemList
 }
 
 // ItemInSlice if a item is in the list
@@ -219,7 +217,7 @@ func GetNameAndExt(uri string) (string, string, error) {
 // Md5 md5 hash
 func Md5(text string) string {
 	sign := md5.New()
-	sign.Write([]byte(text))
+	sign.Write([]byte(text)) // nolint
 	return fmt.Sprintf("%x", sign.Sum(nil))
 }
 
@@ -249,7 +247,7 @@ func M3u8URLs(uri string) ([]string, error) {
 				if err != nil {
 					continue
 				}
-				urls = append(urls, fmt.Sprintf("%s", base.ResolveReference(u)))
+				urls = append(urls, base.ResolveReference(u).String())
 			}
 		}
 	}
diff --git a/utils/utils_test.go b/utils/utils_test.go
index 53bb99ff4..98bea36f6 100644
--- a/utils/utils_test.go
+++ b/utils/utils_test.go
@@ -4,11 +4,9 @@ import (
 	"os"
 	"reflect"
 	"testing"
-
-	"github.com/iawia002/annie/config"
 )
 
-func TestGetStringFromJson(t *testing.T) {
+func TestGetStringFromJSON(t *testing.T) {
 	type args struct {
 		json string
 		path string
@@ -37,8 +35,8 @@ func TestGetStringFromJson(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := GetStringFromJson(tt.args.json, tt.args.path); !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("GetStringFromJson() = %v, want %v", got, tt.want)
+			if got := GetStringFromJSON(tt.args.json, tt.args.path); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("GetStringFromJSON() = %v, want %v", got, tt.want)
 			}
 		})
 	}
@@ -192,7 +190,7 @@ func TestDomain(t *testing.T) {
 			args: args{
 				url: "http://aa",
 			},
-			want: "Universal",
+			want: "",
 		},
 	}
 	for _, tt := range tests {
@@ -273,7 +271,7 @@ func TestFileName(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := FileName(tt.args.name, ""); got != tt.want {
+			if got := FileName(tt.args.name, "", 80); got != tt.want {
 				t.Errorf("FileName() = %v, want %v", got, tt.want)
 			}
 		})
@@ -312,15 +310,11 @@ func TestFilePath(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got, _ := FilePath(tt.args.name, tt.args.ext, tt.args.escape); got != tt.want {
+			if got, _ := FilePath(tt.args.name, tt.args.ext, 80, "", tt.args.escape); got != tt.want {
 				t.Errorf("FilePath() = %v, want %v", got, tt.want)
 			}
 		})
 	}
-
-	// error test
-	config.OutputPath = "test"
-	FilePath("", "", true)
 }
 
 func TestItemInSlice(t *testing.T) {
@@ -602,11 +596,8 @@ func TestParsingFile(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			config.ItemStart = tt.start
-			config.ItemEnd = tt.end
-			config.Items = tt.items
 			file, _ := os.Open(tt.args.filePath)
-			got := ParseInputFile(file)
+			got := ParseInputFile(file, tt.items, tt.start, tt.end)
 			file.Close()
 			if len(got) != tt.want {
 				t.Errorf("Got: %v - want: %v", len(got), tt.want)
@@ -616,22 +607,20 @@ func TestParsingFile(t *testing.T) {
 
 	// test for start from x
 	t.Run("start from x", func(t *testing.T) {
-		config.ItemStart = 5
-		config.ItemEnd = 0
-		config.Items = ""
-		config.File = "./utils_test.go"
-		file, _ := os.Open(config.File)
+		start := 5
+		filePath := "./utils_test.go"
+		file, _ := os.Open(filePath)
 		linesCount, _ := FileLineCounter(file)
 		file.Close()
 
-		file, _ = os.Open(config.File)
-		got := ParseInputFile(file)
+		file, _ = os.Open(filePath)
+		got := ParseInputFile(file, "", start, 0)
 		defer file.Close()
 
 		// start from line x to the end of the file
 		// remember that the slices begin with 0 thats why it finds one line less
-		if len(got) != linesCount-config.ItemStart {
-			t.Errorf("Got: %v - want: %v", len(got), linesCount-config.ItemStart)
+		if len(got) != linesCount-start {
+			t.Errorf("Got: %v - want: %v", len(got), linesCount-start)
 		}
 	})
 }