mirror of
https://github.com/ksyasuda/aniwrapper.git
synced 2024-11-22 03:19:53 -08:00
991 lines
31 KiB
Bash
Executable File
991 lines
31 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
|
|
AGENT="Mozilla/5.0 (X11; Linux x86_64; rv:99.0) Gecko/20100101 Firefox/99.0"
|
|
BASE_URL="https://animixplay.to"
|
|
CFG_DIR="${XDG_CONFIG_HOME:-$HOME/.config}/aniwrapper"
|
|
JOBFILE="${XDG_CACHE_HOME:-$HOME/.cache}/aniwrapper-jobs"
|
|
TMPDIR="${XDG_CACHE_HOME:-$HOME/.cache}/aniwrapper-temp"
|
|
HISTORY_DB="$CFG_DIR/history.sqlite3"
|
|
ROFI_CFG="$CFG_DIR/themes/aniwrapper.rasi"
|
|
ROFI_THEME="aniwrapper.rasi"
|
|
THEMES="alter|aniwrapper|dracula|doomone|fancy|material|monokai|nord|nord2|onedark"
|
|
ANIWRAPPER_ICON_PATH="$CFG_DIR/icons/icon-64.png"
|
|
MAISAN_ICON_PATH="$CFG_DIR/icons/MYsan.png"
|
|
DPI=96
|
|
IS_ROFI=1
|
|
VERBOSE=0
|
|
SILENT=0
|
|
FIRST_EP_NUMBER=1
|
|
PLAYER_FN="mpv"
|
|
PID=0
|
|
|
|
# display error message and exit
|
|
die() {
|
|
((!SILENT)) && printf "\033[1;31m%s\033[0m\n" "$*" >&2
|
|
exit 1
|
|
}
|
|
|
|
# display a log message if verbose mode is enabled
|
|
lg() {
|
|
((VERBOSE)) && printf "\033[1;35m%s\033[0m\n" "$*" >&2
|
|
}
|
|
|
|
# display an informational message (first argument in green, second in magenta)
|
|
inf() {
|
|
printf "\33[2K\r\033[1;35m%s \033[1;35m%s\033[0m\n" "$1" "$2"
|
|
}
|
|
|
|
progress() {
|
|
((!SILENT)) && printf "\33[2K\r\033[1;34m%s\033[0m\n" "$1" >&2
|
|
}
|
|
|
|
# sends a notification to notify-send if available, else prints to stdout
|
|
notification() {
|
|
((SILENT)) && return 0
|
|
msg="$*"
|
|
if command -v "notify-send" > /dev/null; then
|
|
notify-send -i "$ANIWRAPPER_ICON_PATH" "$msg"
|
|
else
|
|
inf "$msg"
|
|
fi
|
|
}
|
|
|
|
# generates a pre-styled span tag with the given msg
|
|
generate_span() {
|
|
msg="$*"
|
|
span="<span foreground='#ecbe7b' style='italic' size='small'>$msg</span>"
|
|
printf "%s\n" "$span"
|
|
}
|
|
|
|
# check if input is valid and assings value/range to episodes variable
|
|
check_input() {
|
|
if [[ -z "$ep_choice_start" ]] && [[ -z "$ep_choice_end" ]]; then
|
|
die "No episode(s) selected"
|
|
fi
|
|
[ "$ep_choice_start" -eq "$ep_choice_start" ] 2> /dev/null || die "Invalid number entered: $ep_choice_start"
|
|
episodes=$ep_choice_start
|
|
if [ -n "$ep_choice_end" ]; then
|
|
[ "$ep_choice_end" -eq "$ep_choice_end" ] 2> /dev/null || die "Invalid number entered: $ep_choice_end"
|
|
episodes=$(seq "$ep_choice_start" "$ep_choice_end")
|
|
fi
|
|
}
|
|
|
|
# download the episode
|
|
# $1: dpage_link | $2: video_url | $3: anime_id | $4: episode | $5: download_dir
|
|
download() {
|
|
case $2 in
|
|
*manifest*m3u8*)
|
|
ffmpeg -loglevel error -stats -referer "$1" -i "$2" -c copy "$3/$4.mp4"
|
|
;;
|
|
*m3u8*)
|
|
progress "Fetching Metadata.."
|
|
[ -d "$TMPDIR" ] || mkdir "$TMPDIR"
|
|
m3u8_data="$(curl -s "$2")"
|
|
key_uri="$(printf "%s" "$m3u8_data" | sed -nE 's/^#EXT-X-KEY.*URI="([^"]*)"/\1/p')"
|
|
m3u8_data="$(printf "%s" "$m3u8_data" | sed "/#/d")"
|
|
printf "%s" "$m3u8_data" | grep -q "http" || relative_url=$(printf "%s" "$2" | sed "s|[^/]*$||")
|
|
range=$(printf "%s\n" "$m3u8_data" | wc -l)
|
|
# Getting and 'decrypting' encryption key
|
|
if [ -n "$key_uri" ]; then
|
|
key=$(curl -s "$key_uri" | od -A n -t x1 | tr -d ' |\n')
|
|
iv=$(openssl rand -hex 16)
|
|
fi
|
|
# Asyncronously downloading pieces to temporary directory
|
|
inf "pieces : $range"
|
|
for i in $(seq "$range"); do
|
|
curl -s "${relative_url}$(printf "%s" "$m3u8_data" | sed -n "${i}p")" > "$TMPDIR/$(printf "%04d" "$i").ts" && printf "\033[2K\r \033[1;32m✓ %s / %s done" "$i" "$range" &
|
|
jobs -p > "$JOBFILE"
|
|
while [ "$(wc -w "$JOBFILE" | cut -d' ' -f1)" -ge 35 ]; do
|
|
jobs > "$JOBFILE"
|
|
sleep 0.05
|
|
done
|
|
done
|
|
wait
|
|
# Decrypting and concatenating the pieces
|
|
if [ -n "$key_uri" ]; then
|
|
progress "Decrypting and Concatenating pieces into single file.."
|
|
for i in "$TMPDIR"/*; do
|
|
openssl enc -aes128 -d -K "$key" -iv "$iv" -nopad >> video.ts < "$i"
|
|
done
|
|
else
|
|
progress "Concatenating pieces into single file.."
|
|
cat "$TMPDIR"/* >> video.ts
|
|
fi
|
|
# cleanup and encoding
|
|
rm -rdf "$TMPDIR" "$JOBFILE"
|
|
inf "Encoding file to mp4 video.."
|
|
ffmpeg -loglevel error -stats -i "video.ts" -c copy "$3/$4.mp4"
|
|
rm -f video.ts
|
|
;;
|
|
*)
|
|
axel -a -k -n 30 --header=Referer:"$1" "$2" -o "$5/$4.mp4"
|
|
;;
|
|
esac
|
|
}
|
|
|
|
generate_link() {
|
|
case $1 in
|
|
1)
|
|
progress "Fetching Mp4upload links.."
|
|
refr=$(printf "%s" "$al_links" | grep "mp4upload")
|
|
[ -z "$refr" ] && refr=$(printf "%s" "$resp" | grep "mp4upload")
|
|
[ -z "$refr" ] && return 0
|
|
result_links="$(curl -A "$AGENT" -s "$refr" -H "DNT: 1" -L |
|
|
sed -nE 's_.*embed\|(.*)\|.*blank.*\|(.*)\|(.*)\|(.*)\|(.*)\|src.*_https://\1.mp4upload.com:\5/d/\4/\3.\2_p')"
|
|
;;
|
|
2)
|
|
progress "Fetching Doodstream links.."
|
|
dood_id=$(printf "%s" "$al_links" | sed -n "s_.*dood.*/e/__p")
|
|
[ -z "$dood_id" ] && dood_id=$(printf "%s" "$resp" | sed -n "s_.*dood.*/e/__p")
|
|
refr="https://dood.pm/e/$dood_id"
|
|
[ -z "$dood_id" ] || dood_md5=$(curl -A "$AGENT" -s "$refr" --max-time 10 | sed -nE "s|.*'(.*pass_md5.*)', func.*|\1|p")
|
|
[ -z "$dood_md5" ] && return 0
|
|
result_links="$(curl -A "$AGENT" -s "https://dood.pm${dood_md5}" -e "$refr" || true)doodstream?token=$(printf "%s" "$dood_md5" | cut -d'/' -f4 || true)&expiry=$(date +%s)000"
|
|
;;
|
|
3)
|
|
progress "Fetching Streamlare links.."
|
|
lare_id=$(printf "%s" "$al_links" | sed -nE 's_.*streamlare.*/e/(.*)_\1_p')
|
|
[ -z "$lare_id" ] && lare_id=$(printf "%s" "$dpage_url" | sed -nE 's_.*streamlare.*/e/(.*)_\1_p')
|
|
refr="https://streamlare.com/e/$lare_id"
|
|
[ -z "$lare_id" ] && return 0
|
|
lare_token=$(curl -s -A "$AGENT" "$refr" -L | sed -nE 's/.*csrf-token.*content="(.*)">/\1/p')
|
|
[ -z "$lare_token" ] || result_links="$(curl -s -A "$AGENT" -H "x-requested-with:XMLHttpRequest" -X POST "https://streamlare.com/api/video/download/get" -d "{\"id\":\"$lare_id\"}" \
|
|
-H "x-csrf-token:$lare_token" -H "content-type:application/json;charset=UTF-8" | sed 's/\\//g' | sed -nE 's/.*url":"([^"]*)".*/\1/p')"
|
|
;;
|
|
4)
|
|
progress "Fetching Okru links.."
|
|
ok_id=$(printf "%s" "$al_links" | sed -nE 's_.*ok.*videoembed/(.*)_\1_p')
|
|
[ -z "$ok_id" ] && ok_id=$(printf "%s" "$dpage_url" | sed -nE 's_.*ok.*videoembed/(.*)_\1_p')
|
|
refr="https://odnoklassniki.ru/videoembed/$ok_id"
|
|
[ -z "$ok_id" ] && return 0
|
|
result_links="$(curl -s "$refr" | sed -nE 's_.*data-options="([^"]*)".*_\1_p' | sed -e 's/"/"/g' -e 's/\u0026/\&/g' -e 's/amp;//g' | sed 's/\\//g' | sed -nE 's/.*videos":(.*),"metadataE.*/\1/p' | tr '{|}' '\n' |
|
|
sed -nE 's/"name":"mobile","url":"(.*)",.*/144p >\1/p ;
|
|
s/"name":"lowest","url":"(.*)",.*/240p >\1/p ;
|
|
s/"name":"low","url":"(.*)",.*/360p >\1/p ;
|
|
s/"name":"sd","url":"(.*)",.*/480p >\1/p ;
|
|
s/"name":"hd","url":"(.*)",.*/720p >\1/p ;
|
|
s/"name":"full","url":"(.*)",.*/1080p >\1/p')"
|
|
;;
|
|
5)
|
|
progress "Fetching Xstreamcdn links.."
|
|
fb_id=$(printf "%s" "$resp" | sed -n "s_.*fembed.*/v/__p")
|
|
refr="https://fembed-hd.com/v/$fb_id"
|
|
[ -z "$fb_id" ] && return 0
|
|
result_links="$(curl -A "$AGENT" -s -X POST "https://fembed-hd.com/api/source/$fb_id" -H "x-requested-with:XMLHttpRequest" |
|
|
sed -e 's/\\//g' -e 's/.*data"://' | tr "}" "\n" | sed -nE 's/.*file":"(.*)","label":"(.*)","type.*/\2>\1/p')"
|
|
;;
|
|
6)
|
|
progress "Fetching Animixplay Direct links.."
|
|
refr="$BASE_URL"
|
|
[ -z "$id" ] && return 0
|
|
enc_id=$(printf "%s" "$id" | base64)
|
|
ani_id=$(printf "%sLTXs3GrU8we9O%s" "$id" "$enc_id" | base64)
|
|
result_links="$(curl -s "$BASE_URL/api/live${ani_id}" -A "$AGENT" -I | sed -nE 's_location: (.*)_\1_p' | cut -d"#" -f2 | base64 -d)"
|
|
;;
|
|
*)
|
|
progress "Fetching Goload Direct links.."
|
|
refr="https://goload.pro"
|
|
[ -z "$id" ] && return 0
|
|
secret_key=$(printf "%s" "$resp" | sed -n '2p' | tr -d "\n" | od -A n -t x1 | tr -d " |\n")
|
|
iv=$(printf "%s" "$resp" | sed -n '3p' | tr -d "\n" | od -A n -t x1 | tr -d " |\n")
|
|
second_key=$(printf "%s" "$resp" | sed -n '4p' | tr -d "\n" | od -A n -t x1 | tr -d " |\n")
|
|
token=$(printf "%s" "$resp" | head -1 | base64 -d | openssl enc -d -aes256 -K "$secret_key" -iv "$iv" | sed -nE 's/.*&(token.*)/\1/p')
|
|
ajax=$(printf '%s' "$id" | openssl enc -e -aes256 -K "$secret_key" -iv "$iv" -a)
|
|
data=$(curl -A "$AGENT" -s -H "X-Requested-With:XMLHttpRequest" "https://goload.pro/encrypt-ajax.php?id=${ajax}&alias=${id}&${token}" | sed -e 's/{"data":"//' -e 's/"}/\n/' -e 's/\\//g')
|
|
result_links="$(printf '%s' "$data" | base64 -d 2> /dev/null | openssl enc -d -aes256 -K "$second_key" -iv "$iv" 2> /dev/null |
|
|
sed -e 's/\].*/\]/' -e 's/\\//g' | grep -Eo 'https:\/\/[-a-zA-Z0-9@:%._\+~#=][a-zA-Z0-9][-a-zA-Z0-9@:%_\+.~#?&\/\/=]*')"
|
|
;;
|
|
esac
|
|
}
|
|
|
|
get_video_quality_mp4() {
|
|
case $quality in
|
|
best)
|
|
video_url=$(printf '%s' "$1" | tail -n 1 | cut -d">" -f2)
|
|
;;
|
|
worst)
|
|
video_url=$(printf '%s' "$1" | head -n 1 | cut -d">" -f2)
|
|
;;
|
|
*)
|
|
video_url=$(printf '%s' "$1" | grep -i "${quality}p" | head -n 1 | cut -d">" -f2)
|
|
if [ -z "$video_url" ]; then
|
|
err "Current video quality is not available (defaulting to best quality)"
|
|
video_url=$(printf '%s' "$1" | tail -n 1 | cut -d">" -f2)
|
|
fi
|
|
;;
|
|
esac
|
|
printf '%s' "$video_url"
|
|
}
|
|
|
|
get_video_quality_m3u8() {
|
|
printf '%s' "$1" | grep -qE "manifest.*m3u.*" && video_url=$1 && return 0
|
|
m3u8_links=$(curl -A "$AGENT" -s --referer "$dpage_link" "$1")
|
|
case $quality in
|
|
best)
|
|
res_selector=$(printf "%s" "$m3u8_links" | sed -nE 's_.*RESOLUTION=.*x([^,]*),.*_\1_p' | sort -nr | head -1)
|
|
;;
|
|
worst)
|
|
res_selector=$(printf "%s" "$m3u8_links" | sed -nE 's_.*RESOLUTION=.*x([^,]*),.*_\1_p' | sort -nr | tail -1)
|
|
;;
|
|
*)
|
|
res_selector=$quality
|
|
if ! (printf '%s' "$m3u8_links" | grep -q "$quality,"); then
|
|
err "Current video quality is not available (defaulting to best quality)"
|
|
res_selector=$(printf "%s" "$m3u8_links" | sed -nE 's_.*RESOLUTION=.*x([^,]*),.*_\1_p' | sort -nr | head -1)
|
|
fi
|
|
;;
|
|
esac
|
|
video_url=$(printf '%s' "$m3u8_links" | sed -n "/$res_selector,/{n;p;}" | tr -d '\r')
|
|
printf "%s" "$m3u8_links" | grep -q "http" || video_url="$(printf "%s" "$1" | sed 's|[^/]*$||')$video_url" || true
|
|
}
|
|
|
|
# chooses the link for the set quality
|
|
get_video_link() {
|
|
dpage_url="$1"
|
|
id=$(printf "%s" "$dpage_url" | sed -nE 's/.*id=(.*)&title.*/\1/p')
|
|
al_links=$(printf "%s" "$al_data" | sed -e 's_:\[_\n_g' -e 's_:"_\n"_g' | sed -e 's/].*//g' -e '1,2d' | sed -n "${episode}p" | tr -d '"' | tr "," "\n")
|
|
[ -z "$id" ] && id=$(printf "%s" "$al_links" | sed -nE 's/.*id=(.*)&title.*/\1/p')
|
|
#multiple sed are used (regex seperated by ';') for extracting only required data from response of embed url
|
|
resp="$(curl -A "$AGENT" -s "https://goload.pro/streaming.php?id=$id" |
|
|
sed -nE 's/.*class="container-(.*)">/\1/p ;
|
|
s/.*class="wrapper container-(.*)">/\1/p ;
|
|
s/.*class=".*videocontent-(.*)">/\1/p ;
|
|
s/.*data-value="(.*)">.*/\1/p ;
|
|
s/.*data-status="1".*data-video="(.*)">.*/\1/p')"
|
|
# providers: Doodstream for default, mp4upload for downloading. For best quality use okru, for fallback use goload. Then it's a round robin of which links are returned.
|
|
provider=2
|
|
uname -a | grep -qE '[Aa]ndroid' && provider=3
|
|
[ "$is_download" -eq 1 ] && provider=1
|
|
[ "$quality" != "best" ] && provider=4
|
|
[ -n "$select_provider" ] && provider="$select_provider"
|
|
i=0
|
|
while [ "$i" -lt 7 ] && [ -z "$result_links" ]; do
|
|
generate_link "$provider"
|
|
provider=$((provider % 7 + 1))
|
|
: $((i += 1))
|
|
done
|
|
if printf '%s' "$result_links" | grep -q "m3u8"; then
|
|
get_video_quality_m3u8 "$result_links"
|
|
else
|
|
video_url=$(get_video_quality_mp4 "$result_links")
|
|
fi
|
|
unset result_links
|
|
}
|
|
|
|
dep_ch() {
|
|
for dep; do
|
|
if ! command -v "$dep" > /dev/null; then
|
|
die "Program \"$dep\" not found. Please install it."
|
|
fi
|
|
done
|
|
}
|
|
|
|
# get anime name along with its id
|
|
search_anime() {
|
|
if [[ $# -gt 1 ]]; then
|
|
# if multi-word query, concatenate into one string and replace spaces with '-'
|
|
search="$*"
|
|
search="${search// /-}"
|
|
else
|
|
# if one word, remove leading or trailing whitespace
|
|
search="${1// /}"
|
|
fi
|
|
lg "Search Query: $search"
|
|
curl -s "https://gogoanime.lu//search.html?keyword=$search" -L |
|
|
sed -nE 's_^[[:space:]]*<a href="/category/([^"]*)" title.*_\1_p'
|
|
}
|
|
|
|
# only lets the user pass in case of a valid search
|
|
process_search() {
|
|
progress "Searching $query.."
|
|
search_results=$(search_anime "$query")
|
|
[ -z "$search_results" ] && die 'No search results found'
|
|
lg "Search Results: $search_results"
|
|
printf "%s\n" "$search_results"
|
|
}
|
|
|
|
# searches on gogoanime (instead of gogoplay) because they index english titles
|
|
extended_search() {
|
|
indexing_url=$(curl -s -L -o /dev/null -w "%{url_effective}\n" https://gogoanime.cm)
|
|
search=$(printf '%s' "$1" | tr ' ' '-')
|
|
curl -s "$indexing_url//search.html" -G -d "keyword=$search" |
|
|
sed -n -E 's_^[[:space:]]*<a href="/category/([^"]*)" title="([^"]*)".*_\1_p'
|
|
}
|
|
|
|
episode_list() {
|
|
data=$(curl -A "$AGENT" -s "$BASE_URL/v1/$1" | sed -nE "s/.*malid = '(.*)';/\1/p ; s_.*epslistplace.*>(.*)</div>_\1_p" | tr -d '\r')
|
|
#extract all embed links of all episode from data
|
|
select_ep_result=$(printf "%s" "$data" | head -1 | tr "," "\n" | sed '/extra/d' | sed -nE 's_".*":"(.*)".*_\1_p')
|
|
lg "Episode List: $select_ep_result"
|
|
FIRST_EP_NUMBER=1
|
|
[ -z "$select_ep_result" ] && LAST_EP_NUMBER=0 || LAST_EP_NUMBER=$(printf "%s\n" "$select_ep_result" | wc -l)
|
|
lg "First Ep: $FIRST_EP_NUMBER, Last Ep: $LAST_EP_NUMBER"
|
|
}
|
|
|
|
#from allanime server
|
|
al_episode_list() {
|
|
ext_id=$(printf "%s" "$data" | tail -1)
|
|
al_server_link=$(curl -s -H "x-requested-with:XMLHttpRequest" -X POST "https://animixplay.to/api/search" -d "recomended=$ext_id" -A "$AGENT" |
|
|
sed -nE 's_.*"AL","items":\[(.*)\]\},.*_\1_p' | tr '{|}' '\n' | sed -nE 's_"url":"(.*)",.*title.*_\1_p')
|
|
[ -z "$al_server_link" ] && return 0
|
|
progress "(Allanime) Searching Episodes.."
|
|
if printf "%s" "$selection_id" | grep -q "dub"; then
|
|
al_server_link=$(printf "%s" "$al_server_link" | grep "dub" | head -1)
|
|
else
|
|
al_server_link=$(printf "%s" "$al_server_link" | sed 's/-dub//' | head -1)
|
|
fi
|
|
al_data=$(curl -s "${BASE_URL}${al_server_link}" -A "$AGENT" | sed -nE 's_.*epslistplace.*>(.*)</div>_\1_p')
|
|
}
|
|
|
|
open_episode() {
|
|
anime_id="$1"
|
|
episode="$2"
|
|
ddir="$3"
|
|
tput clear
|
|
progress "Loading episode $episode of $anime_id"
|
|
|
|
insert_history "watch" "$anime_id" "$episode"
|
|
|
|
dpage_link=$(printf "%s" "$select_ep_result" | sed -n "${episode}p")
|
|
lg "dpage_link: $dpage_link"
|
|
if [[ -z "$dpage_link" ]]; then
|
|
die "Could not get download page link"
|
|
else
|
|
get_video_link "$dpage_link"
|
|
fi
|
|
lg "Video url: $video_url"
|
|
[ -z "$video_url" ] && die "Video URL not found"
|
|
[ ! "$PID" = "0" ] && kill "$PID" > /dev/null 2>&1
|
|
|
|
if [ "$is_download" -eq 0 ]; then
|
|
lg "PLAYING: $video_url with player: $PLAYER_FN"
|
|
case "$PLAYER_FN" in
|
|
mpv)
|
|
nohup "$PLAYER_FN" "$video_url" --referrer="$refr" --force-media-title="aniwrapper: $anime_id E$(printf "%03d" "$episode")" > /dev/null 2>&1 &
|
|
;;
|
|
vlc)
|
|
nohup "$PLAYER_FN" --play-and-exit --http-referrer="$refr" "$video_url" > /dev/null 2>&1 &
|
|
;;
|
|
*)
|
|
nohup "$PLAYER_FN" "$video_url" > /dev/null 2>&1 & # try to open with just the video url
|
|
;;
|
|
esac
|
|
PID=$!
|
|
if command -v "notify-send" > /dev/null; then
|
|
((!SILENT)) && notify-send -i "$ANIWRAPPER_ICON_PATH" "Playing $anime_id - Episode $episode"
|
|
else
|
|
((!SILENT)) && inf "Playing $anime_id - Episode $episode"
|
|
fi
|
|
if ((is_autoplay)); then
|
|
lg "Waiting for video to finish playing..."
|
|
wait "$PID"
|
|
if ((episode + 1 <= LAST_EP_NUMBER)) && continue_watching; then
|
|
open_episode "$anime_id" "$((episode + 1))" "$ddir"
|
|
else
|
|
exit 0
|
|
fi
|
|
fi
|
|
else
|
|
lg "Downloading episode $episode ..."
|
|
dl_dir="${ddir// /}/$anime_id"
|
|
episode=$(printf "%03d" "$episode") # add 0 padding to the episode name
|
|
{
|
|
mkdir -p "$dl_dir" || die "Could not create directory"
|
|
if command -v "notify-send" > /dev/null; then
|
|
if download "$refr" "$video_url" "$anime_id" "$episode" "$dl_dir"; then
|
|
((!SILENT)) && notify-send -i "$ANIWRAPPER_ICON_PATH" "Download complete for ${anime_id//-/ } - Episode: $episode"
|
|
else
|
|
((!SILENT)) && notify-send -i "$MAISAN_ICON_PATH" "Download failed for ${anime_id//-/ } - Episode: $episode. Please retry or check your internet connection"
|
|
fi
|
|
else
|
|
if download "$refr" "$video_url" "$anime_id" "$episode" "$dl_dir"; then
|
|
((!SILENT)) && inf "Download complete for" "${anime_id//-/ } - Episode $episode"
|
|
else
|
|
((!SILENT)) && inf "Download failed for" "${anime_id//-/ } - Episode $episode, please retry or check your internet connection"
|
|
fi
|
|
fi
|
|
}
|
|
fi
|
|
}
|
|
|
|
stream() {
|
|
lg "Running stream()"
|
|
if [ "$#" -eq 0 ]; then
|
|
get_search_query
|
|
else
|
|
get_search_query "$*"
|
|
fi
|
|
anime_id="$query"
|
|
[ -z "$anime_id" ] && die "No anime selected or queried"
|
|
searched=0
|
|
lg "Checking if anime: $anime_id has been searched before..."
|
|
if ! check_db "search" "$anime_id"; then
|
|
lg "$anime_id has been searched before"
|
|
selection_id="$anime_id"
|
|
insert_history "search" "$anime_id" &
|
|
episode_list "$anime_id"
|
|
al_episode_list
|
|
else
|
|
search_results=$(process_search $query) # want word splitting to account for both input cases
|
|
[ -z "$search_results" ] && die
|
|
if ! anime_selection "$search_results"; then
|
|
die "No anime selection found"
|
|
fi
|
|
fi
|
|
if (((FIRST_EP_NUMBER == LAST_EP_NUMBER && (FIRST_EP_NUMBER == 0 || FIRST_EP_NUMBER == 1)))); then
|
|
ep_choice_start=1
|
|
else
|
|
episode_selection
|
|
fi
|
|
}
|
|
|
|
parse_args() {
|
|
download_dir="."
|
|
scrape=query
|
|
quality=best
|
|
is_download=0
|
|
is_resume=0
|
|
is_autoplay=0
|
|
while getopts 'ad:Hsvq:cf:t:T:CQ:D:Sp:rR' OPT; do
|
|
case "$OPT" in
|
|
a)
|
|
is_autoplay=1
|
|
;;
|
|
d)
|
|
is_download=1
|
|
download_dir="$OPTARG"
|
|
lg "DOWNLOAD DIR: $download_dir"
|
|
;;
|
|
r)
|
|
is_resume=1
|
|
;;
|
|
R)
|
|
scrape=recent
|
|
;;
|
|
H)
|
|
scrape=history
|
|
;;
|
|
s)
|
|
scrape=sync
|
|
;;
|
|
v)
|
|
VERBOSE=1
|
|
;;
|
|
q)
|
|
quality="$OPTARG"
|
|
lg "passed in quality: $quality"
|
|
;;
|
|
c)
|
|
IS_ROFI=0
|
|
;;
|
|
f)
|
|
scrape="file"
|
|
play_dir="$OPTARG"
|
|
[ "$play_dir" != "/" ] && play_dir="$(sed -E 's/\/$//' <<< "$play_dir")" # remove trailing slash... unless searching / for some reason
|
|
;;
|
|
t)
|
|
theme="$OPTARG"
|
|
case "$theme" in
|
|
aniwrapper | default)
|
|
ROFI_THEME=aniwrapper.rasi
|
|
;;
|
|
*)
|
|
if [[ "$theme" =~ ($THEMES) ]]; then
|
|
ROFI_THEME="aniwrapper-$theme.rasi"
|
|
else
|
|
die "Invalid theme: $theme. Please choose from: $THEMES"
|
|
fi
|
|
;;
|
|
esac
|
|
lg "Setting theme for ani-cli -> $ROFI_THEME"
|
|
ROFI_CFG="$CFG_DIR/themes/$ROFI_THEME"
|
|
lg "ROFI_CFG: $ROFI_CFG"
|
|
;;
|
|
T)
|
|
ROFI_CFG="$OPTARG"
|
|
[ ! -f "$ROFI_CFG" ] && die "$ROFI_CFG does not exist"
|
|
lg "CUSTOM ROFI_CFG: $ROFI_CFG"
|
|
;;
|
|
C)
|
|
lg "Connecting to history database -> $CFG_DIR/history.sqlite3"
|
|
sqlite3 "$CFG_DIR/history.sqlite3"
|
|
exit $?
|
|
;;
|
|
Q)
|
|
query="$OPTARG"
|
|
lg "DATABASE QUERY: $query"
|
|
sqlite3 -line "$CFG_DIR/history.sqlite3" "$query"
|
|
exit $?
|
|
;;
|
|
D)
|
|
DPI="$OPTARG"
|
|
;;
|
|
S)
|
|
SILENT=1
|
|
;;
|
|
p)
|
|
PLAYER_FN="$OPTARG"
|
|
if ! command -v "$PLAYER_FN" > /dev/null; then
|
|
die "ERROR: $PLAYER_FN does not exist"
|
|
fi
|
|
;;
|
|
*)
|
|
inf "Invalid option"
|
|
exit 1
|
|
;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
show_menu() {
|
|
if ((!SILENT)); then
|
|
episode=${ep_choice_end:-$ep_choice_start}
|
|
choice=''
|
|
while :; do
|
|
inf "Currently playing $selection_id episode" "${episode// /}/$LAST_EP_NUMBER"
|
|
((episode != LAST_EP_NUMBER)) && menu_line_alternate "next episode" "n"
|
|
((episode != FIRST_EP_NUMBER)) && menu_line_alternate "previous episode" "p"
|
|
((FIRST_EP_NUMBER != LAST_EP_NUMBER)) && menu_line_alternate "select episode" "s"
|
|
menu_line_alternate "replay current episode" "r"
|
|
menu_line_alternate "search for another anime" "a"
|
|
menu_line_alternate "download current episode" "d"
|
|
menu_line_alternate "download current episode (with quality selection)" "D"
|
|
menu_line_alternate "select video quality (current: $quality)" "Q"
|
|
menu_line_strong "exit" "q"
|
|
prompt "Enter choice"
|
|
read -r choice
|
|
case $choice in
|
|
n)
|
|
episode=$((episode + 1))
|
|
;;
|
|
p)
|
|
episode=$((episode - 1))
|
|
;;
|
|
|
|
s)
|
|
episode_selection
|
|
episode=$ep_choice_start
|
|
;;
|
|
|
|
r)
|
|
episode=$((episode))
|
|
;;
|
|
a)
|
|
stream
|
|
[ -z "$ep_choice_start" ] && die "No episode selected"
|
|
episode=$ep_choice_start
|
|
lg "New selection: $selection_id - $episode"
|
|
;;
|
|
Q)
|
|
set_video_quality
|
|
episode=$((episode))
|
|
;;
|
|
|
|
d)
|
|
get_dl_dir
|
|
is_download=1
|
|
;;
|
|
D)
|
|
get_dl_dir
|
|
set_video_quality
|
|
is_download=1
|
|
;;
|
|
q)
|
|
break
|
|
;;
|
|
|
|
*)
|
|
die "invalid choice"
|
|
;;
|
|
esac
|
|
open_episode "$selection_id" "$episode" "$download_dir"
|
|
done
|
|
fi
|
|
}
|
|
|
|
main() {
|
|
case $scrape in
|
|
query)
|
|
stmt="SELECT anime_name FROM watch_history ORDER BY watch_date DESC LIMIT 1;"
|
|
((is_resume)) && anime="$(run_stmt "$stmt")" || anime="$*"
|
|
if [ -z "$anime" ]; then
|
|
stream
|
|
else
|
|
stream "$anime"
|
|
fi
|
|
;;
|
|
history)
|
|
stmt="SELECT anime_name FROM search_history ORDER BY search_date DESC"
|
|
search_results="$(run_stmt "$stmt")"
|
|
[ -z "$search_results" ] && die "History is empty"
|
|
if ! anime_selection "${search_results[@]}"; then
|
|
die "No anime selected"
|
|
fi
|
|
lg "SELECTION: $selection_id"
|
|
|
|
stmt="SELECT episode_number FROM watch_history WHERE anime_name = '$selection_id' ORDER BY watch_date DESC LIMIT 1;"
|
|
ep_choice_start=$(run_stmt "$stmt")
|
|
lg "Most recently watched episode: $ep_choice_start"
|
|
;;
|
|
sync)
|
|
prompt "Enter username for remote user"
|
|
read -r username
|
|
prompt "Enter host for remote user"
|
|
read -r host
|
|
|
|
connection_str="$username@$host"
|
|
prompt "Enter port to connect to remote host with or leave blank for default (22)"
|
|
read -r port
|
|
[ -z "$port" ] && PORT=22 || PORT="$port"
|
|
|
|
prompt "Enter path to private key (leave blank if unsure or not needed)"
|
|
read -r key_path
|
|
|
|
lg "Syncing database with: $connection_str on port $PORT"
|
|
temp_db="/tmp/aniwrapper_tmp_history.sqlite3"
|
|
|
|
if [[ -z "$key_path" ]]; then
|
|
if ! scp -P "$PORT" "$connection_str:$HISTORY_DB" "$temp_db"; then
|
|
die "Error getting database file from remote host"
|
|
fi
|
|
else
|
|
if ! scp -P "$PORT" -i "$key_path" "$connection_str:$HISTORY_DB" "$temp_db"; then
|
|
die "Error getting database file from remote host"
|
|
fi
|
|
fi
|
|
sync_search_history && sync_watch_history
|
|
exit $?
|
|
;;
|
|
file)
|
|
lg "STARTING DIR: $play_dir"
|
|
[ ! -d "$play_dir" ] && die "$play_dir does not exist"
|
|
insert_history "directory" "$play_dir"
|
|
video_path="$(find_media "$play_dir")"
|
|
retcode="$?"
|
|
if [ "$retcode" -ne 0 ]; then
|
|
die
|
|
elif [ -z "$video_path" ]; then
|
|
die "Something went wrong getting path... path is empty"
|
|
fi
|
|
lg "VIDEO PATH: $video_path"
|
|
play_file "$video_path"
|
|
exit $?
|
|
;;
|
|
recent)
|
|
# get list of recently added anime from $BASE_URL
|
|
lg "Getting list of recently added anime"
|
|
recently_updated="$(curl -A "$AGENT" -s "$BASE_URL" | grep -oE '/v1/([^"]*)' | sed -E 's/\/v1\///')"
|
|
while read -r updated_episode; do
|
|
anime_name="${updated_episode%%/*}"
|
|
lg "ANIME NAME: $anime_name"
|
|
if ! check_db "search" "$anime_name"; then
|
|
stmt="SELECT COUNT(*) FROM watch_history WHERE anime_name = '$anime_name' AND episode_number = '${updated_episode##*/ep}';"
|
|
lg "QUERY: $stmt"
|
|
if [[ "$(run_stmt "$stmt")" -ne 0 ]]; then
|
|
lg "$updated_episode watched before... adding to watched list"
|
|
[[ -z "$watched" ]] && watched="$cnt" || watched="$watched, $cnt"
|
|
fi
|
|
fi
|
|
((++cnt))
|
|
done <<< "$recently_updated"
|
|
selection="$(rofi -dpi "$DPI" -dmenu -no-custom -config "$ROFI_CFG" \
|
|
-l 15 -a "$watched" -i -p "Enter selection" -async-pre-read 30 \
|
|
-window-title 'aniwrapper' <<< "$recently_updated")"
|
|
if [ -z "$selection" ]; then
|
|
die "No selection made"
|
|
fi
|
|
lg "SELECTION: $selection"
|
|
# get everything before -episode-
|
|
selection_id="${selection%%/*}"
|
|
# get everything after -episode-
|
|
ep_choice_start="${selection##*/ep}"
|
|
episode_list "$selection_id"
|
|
al_episode_list
|
|
;;
|
|
esac
|
|
|
|
check_input
|
|
|
|
for ep in $episodes; do
|
|
open_episode "$selection_id" "$ep" "$download_dir"
|
|
done
|
|
|
|
if ((is_download)); then
|
|
lg "Finished downloading episodes: $episodes for $selection_id... exiting"
|
|
exit 0
|
|
elif ((!is_autoplay)); then
|
|
show_menu
|
|
fi
|
|
}
|
|
|
|
# runs sql command on the history database
|
|
run_stmt() {
|
|
printf "%s\n" "$1" | sqlite3 -noheader -list "$HISTORY_DB"
|
|
}
|
|
|
|
# Return number of matches for anime/episode in db
|
|
check_db() {
|
|
case "$1" in
|
|
directory)
|
|
stmt="SELECT COUNT(*) FROM file_history WHERE directory = '$2';"
|
|
;;
|
|
file)
|
|
stmt="SELECT COUNT(*) FROM file_history WHERE directory = '$2' AND filename = '$3';"
|
|
;;
|
|
search)
|
|
stmt="SELECT COUNT(*) FROM search_history WHERE anime_name = '$2';"
|
|
;;
|
|
watch | sync)
|
|
stmt="SELECT COUNT(*) FROM watch_history WHERE anime_name = '$2' AND episode_number = '$3';"
|
|
;;
|
|
anime)
|
|
stmt="SELECT COUNT(*) FROM anime WHERE anime_name = '$2';"
|
|
;;
|
|
esac
|
|
res=$(run_stmt "$stmt")
|
|
return "$res"
|
|
}
|
|
|
|
# return true (0) if $source_dt > $target_dt
|
|
check_date() {
|
|
source_dt="$1"
|
|
target_dt="$2"
|
|
if [[ "$source_dt" < "$target_dt" ]] || [[ "$source_dt" == "$target_dt" ]]; then
|
|
return 1
|
|
else
|
|
return 0
|
|
fi
|
|
}
|
|
|
|
# updates search/watch date for passed in anime
|
|
update_date() {
|
|
datetime=$(date +'%Y-%m-%d %H:%M:%S')
|
|
stmt=""
|
|
case "$1" in
|
|
directory)
|
|
stmt="UPDATE file_history SET watch_date = '$datetime' WHERE directory = '$2' and filename = 'DIRECTORY';"
|
|
;;
|
|
file)
|
|
stmt="UPDATE file_history SET watch_date = '$datetime' WHERE directory = '$2' and filename = '$3';"
|
|
;;
|
|
search)
|
|
stmt="UPDATE search_history SET search_date = '$datetime' WHERE anime_name = '$2';"
|
|
;;
|
|
sync)
|
|
temp_dt="${3// /:}"
|
|
[ -z "$temp_dt" ] && return 1
|
|
hist_dt=$(run_stmt "SELECT watch_date FROM watch_history WHERE anime_name='$2' AND episode_number='$3';")
|
|
hist_dt="${hist_dt// /:}"
|
|
if ! check_date "$hist_dt" "$temp_dt"; then
|
|
lg "Passed in date is older or same than current date... doing nothing"
|
|
return 1
|
|
fi
|
|
stmt="UPDATE watch_history SET watch_date = '$temp_dt' WHERE anime_name = '$2' AND episode_number = $3;"
|
|
;;
|
|
watch)
|
|
stmt="UPDATE watch_history SET watch_date = '$datetime' WHERE anime_name = '$2' AND episode_number = $3;"
|
|
;;
|
|
anime)
|
|
return
|
|
;;
|
|
esac
|
|
lg "UPDATE STMT -> $stmt"
|
|
run_stmt "$stmt"
|
|
}
|
|
|
|
# inserts into search/watch history db
|
|
# check the anime_name/id
|
|
insert_history() {
|
|
datetime=$(date +'%Y-%m-%d %H:%M:%S')
|
|
lg "Checking if ($*) exists in db"
|
|
if ! check_db "$@"; then
|
|
lg "Match found... Updating row in history db..."
|
|
update_date "$@"
|
|
res=$?
|
|
else
|
|
lg "Row not found in DB... inserting"
|
|
case "$1" in
|
|
directory)
|
|
stmt="INSERT INTO file_history(directory, filename, watch_date) VALUES('$2', 'DIRECTORY', '$datetime');"
|
|
;;
|
|
file)
|
|
stmt="INSERT INTO file_history(directory, filename, watch_date) VALUES('$2', '$3', '$datetime');"
|
|
;;
|
|
search)
|
|
stmt="INSERT INTO search_history(anime_name, search_date) VALUES('$2', '$datetime');"
|
|
;;
|
|
watch)
|
|
stmt="INSERT INTO watch_history(anime_name, episode_number, watch_date) VALUES('$2', '$3', '$datetime');"
|
|
;;
|
|
sync)
|
|
stmt="INSERT INTO watch_history(anime_name, episode_number, watch_date) VALUES('$2', '$3', '$4');"
|
|
;;
|
|
anime)
|
|
stmt="INSERT INTO anime(anime_name, start_episode, end_episode, data_date) VALUES('$2', $3, $4, '$datetime');"
|
|
;;
|
|
esac
|
|
lg "INSERT STATEMENT -> $stmt"
|
|
run_stmt "$stmt"
|
|
res=$?
|
|
fi
|
|
return $res
|
|
}
|
|
|
|
sync_search_history() {
|
|
cnt=0
|
|
errs=0
|
|
while read -r line; do
|
|
anime_name=$(awk -F '|' '{print $2}' <<< "$line")
|
|
if sqlite3 -noheader "$HISTORY_DB" "SELECT COUNT(*) FROM search_history WHERE anime_name = '$anime_name'"; then
|
|
search_date=$(awk -F '|' '{print $3}' <<< "$line")
|
|
if ! sqlite3 "$HISTORY_DB" "INSERT INTO search_history(anime_name, search_date) VALUES('$anime_name', '$search_date')"; then
|
|
((++errs))
|
|
continue
|
|
fi
|
|
((++cnt))
|
|
fi
|
|
done < <(sqlite3 -list -noheader "$temp_db" "SELECT * FROM search_history")
|
|
lg "$cnt rows inserted into search_history table"
|
|
lg "$errs errors on insert"
|
|
}
|
|
|
|
sync_watch_history() {
|
|
cnt=0
|
|
errs=0
|
|
while read -r line; do
|
|
anime_name="${line/ //}"
|
|
while read -r ep; do
|
|
episode_num=$(awk -F '|' '{print $1}' <<< "$ep")
|
|
watch_date=$(awk -F '|' '{print $NF}' <<< "$ep")
|
|
if ! insert_history "sync" "$anime_name" "$episode_num" "$watch_date"; then
|
|
((++errs))
|
|
continue
|
|
fi
|
|
((++cnt))
|
|
done < <(sqlite3 -list -noheader "$temp_db" "SELECT episode_number, watch_date FROM watch_history WHERE anime_name = '$anime_name'")
|
|
done < <(sqlite3 -list -noheader "$temp_db" "SELECT anime_name FROM watch_history")
|
|
lg "$cnt rows inserted into watch_history table"
|
|
lg "$errs rows skipped on insert"
|
|
}
|
|
|
|
# opens the passed in file with $PLAYER_FN
|
|
play_file() {
|
|
lg "Checking if file is playable"
|
|
if [[ "$1" =~ (\.mp4|\.mkv|\.ts|\.webm)$ ]]; then
|
|
filename="${1##*/}"
|
|
directory="${1%/*}"
|
|
insert_history "file" "$directory" "$filename"
|
|
notification "Playing $1"
|
|
case "$PLAYER_FN" in
|
|
mpv)
|
|
nohup "$PLAYER_FN" --force-media-title="aniwrapper: play-from-file - $1" "$1" > /dev/null 2>&1 &
|
|
;;
|
|
*)
|
|
nohup "$PLAYER_FN" "$1" > /dev/null 2>&1 &
|
|
;;
|
|
esac
|
|
return $?
|
|
else
|
|
die "File: $1 is not playable... Quitting"
|
|
fi
|
|
}
|
|
|
|
# gets the list of directories and playable files from the passed in directory
|
|
# sets the $watched list to the list of watched files
|
|
get_directory_data() {
|
|
search_dir="$1"
|
|
inputlist=""
|
|
watched=""
|
|
cnt=1
|
|
[ "$search_dir" = "/" ] && cnt=0 # account for no ../ on /
|
|
for directory in "$1"/*; do
|
|
directory="${directory##*/}"
|
|
[ ! -d "$search_dir/$directory" ] && continue
|
|
[ -z "$inputlist" ] && inputlist="$directory" || inputlist="$inputlist|$directory"
|
|
if ! check_db "directory" "$search_dir/$directory"; then
|
|
lg "$search_dir/$directory opened before... adding $cnt to list" 1> /dev/stderr
|
|
[ -z "$watched" ] && watched="$cnt" || watched="$watched, $cnt"
|
|
fi
|
|
((++cnt))
|
|
done
|
|
shopt -s nullglob # set nullglob to avoid printing output if no files with extension exist
|
|
shopt -s nocaseglob # case insensitive globbing
|
|
for filename in "$search_dir"/*.{mp4,mkv,ts,mp3,webm}; do
|
|
filename="${filename##*/}"
|
|
[ -z "$inputlist" ] && inputlist="$filename" || inputlist="$inputlist|$filename"
|
|
if ! check_db "file" "$search_dir" "$filename"; then
|
|
lg "$filename watched before... adding $cnt to list" 1> /dev/stderr
|
|
[ -z "$watched" ] && watched="$cnt" || watched="$watched, $cnt"
|
|
fi
|
|
((++cnt))
|
|
done
|
|
shopt -u nullglob
|
|
shopt -u nocaseglob
|
|
if [[ -n "$inputlist" && "$search_dir" != / ]]; then
|
|
inputlist="../|$inputlist|Back|Quit"
|
|
elif [[ -z "$inputlist" && "$search_dir" != / ]]; then
|
|
inputlist="../|Back|Quit"
|
|
elif [[ "$search_dir" = / ]]; then
|
|
inputlist="$inputlist|Quit"
|
|
else
|
|
inputlist="Quit"
|
|
fi
|
|
lg "INPUT LIST: $inputlist" 1> /dev/stderr
|
|
lg "WATCHED LIST: $watched" 1> /dev/stderr
|
|
}
|
|
|
|
# recursive function for finding path to video file given a starting directory
|
|
find_media() {
|
|
inp="$1"
|
|
[ -z "$inp" ] && die "No directory"
|
|
lg "BEGIN find_media() on $inp" 1> /dev/stderr
|
|
|
|
# base case hit when a file is found
|
|
if [ -f "$inp" ]; then
|
|
printf "%s\n" "$inp"
|
|
return 0
|
|
fi
|
|
|
|
get_directory_data "$inp"
|
|
selection="$(rofi -dpi "$DPI" -dmenu -no-custom -async-pre-read 33 -config "$ROFI_CFG" \
|
|
-l 15 -i -sep '|' -mesg "$(generate_span "Current directory: $inp")" -a "$watched" \
|
|
-p "Enter selection" -window-title 'aniwrapper' <<< "$inputlist")"
|
|
[ -z "$selection" ] && return 1
|
|
case "$selection" in
|
|
Back | ../)
|
|
dotdotslash="${inp%/*}"
|
|
[ -z "$dotdotslash" ] && dotdotslash="/"
|
|
insert_history "directory" "$dotdotslash"
|
|
find_media "$dotdotslash"
|
|
;;
|
|
Quit)
|
|
return 1
|
|
;;
|
|
*)
|
|
if [ -d "$inp/$selection" ]; then
|
|
insert_history "directory" "$inp/$selection"
|
|
if [ "$inp" = "/" ]; then
|
|
find_media "/$selection"
|
|
else
|
|
find_media "$inp/$selection"
|
|
fi
|
|
else
|
|
find_media "$inp/$selection"
|
|
fi
|
|
;;
|
|
esac
|
|
}
|
|
|
|
progress "Checking dependencies..."
|
|
dep_ch "$PLAYER_FN" "curl" "sed" "grep" "sqlite3" "rofi" "git" "axel" "openssl" "ffmpeg"
|
|
parse_args "$@"
|
|
shift $((OPTIND - 1))
|
|
if ((IS_ROFI)); then
|
|
. "$CFG_DIR/lib/ani-cli/UI-ROFI" || die "No UI file"
|
|
lg "rofi UI loaded"
|
|
else
|
|
. "$CFG_DIR/lib/ani-cli/UI" || die "No UI file"
|
|
lg "command-line UI loaded"
|
|
fi
|
|
main "$@"
|