ms = (seconds * 1000) % 1000

m, s = divmod(seconds, 60)

h, m = divmod(m, 60)

global p, _player

fields = {}

for item in mw.reviewer.card.note().items():

fields[item[0]] = item[1]

# if path is not None and os.path.exists(path):

# _player(path)

# return

if not path:

if state is not None:

path = fields["Audio"]

else:

path = fields["Video"]

path = strip_html(path)

path = path.replace('[sound:', '')

path = path.replace(']', '')

# elif path.endswith(".mp3"): # workaround to fix replay button (R) without refreshing webview.

# path = fields["Audio"]

# else:

# path = fields["Video"]

# if mw.reviewer.state == "question" and mw.reviewer.card.note_type()["name"] == "movies2anki - subs2srs (video)":

# path = fields["Video"]

m = re.fullmatch(r"(.*?)_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*", path)

if not m:

return False

card_prefix, time_start, time_end = m.groups()

time_start = timeToSeconds(time_start)

time_end = timeToSeconds(time_end)

if state == None and (isPrev or isNext):

cards = sorted(mw.col.findCards('"Id:{}_*"'.format(card_prefix), order=True))

card_idx = cards.index(mw.reviewer.card.id)

prev_card_idx = card_idx - 1 if card_idx - 1 > 0 else 0

next_card_idx = card_idx + 1

if next_card_idx >= len(cards):

next_card_idx = len(cards) - 1

if (isPrev and mw.col.getCard(cards[prev_card_idx]).id == mw.reviewer.card.id):

tooltip("It's the first card.")

return

if (isNext and mw.col.getCard(cards[next_card_idx]).id == mw.reviewer.card.id):

tooltip("It's the last card.")

return

curr_card = mw.col.getCard(cards[card_idx])

prev_card = mw.col.getCard(cards[prev_card_idx])

next_card = mw.col.getCard(cards[next_card_idx])

prev_card_audio = prev_card.note()["Audio"]

next_card_audio = next_card.note()["Audio"]

# TODO compare Id field prefix or Path field or limit search by Path or maybe something else

m = re.fullmatch(r".*?_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*", prev_card_audio)

prev_time_start, prev_time_end = m.groups()

prev_time_start = timeToSeconds(prev_time_start)

prev_time_end = timeToSeconds(prev_time_end)

m = re.fullmatch(r".*?_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*", next_card_audio)

next_time_start, next_time_end = m.groups()

next_time_start = timeToSeconds(next_time_start)

next_time_end = timeToSeconds(next_time_end)

if isPrev:

time_start = prev_time_start

if isNext:

time_end = next_time_end

if state != None:

if state == "start":

time_start = time_start - shift

elif state == "end":

time_end = time_end + shift

# elif state == "start reset":

# m = re.match(r"^.*?_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*$", fields["Id"])

# id_time_start, id_time_end = m.groups()

# id_time_start = timeToSeconds(id_time_start)

# time_start = id_time_start

# elif state == "end reset":

# m = re.match(r"^.*?_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*$", fields["Id"])

# id_time_start, id_time_end = m.groups()

# id_time_end = timeToSeconds(id_time_end)

# time_end = id_time_end

time_interval = "%s-%s" % (secondsToTime(time_start), secondsToTime(time_end))

mw.reviewer.card.note()["Id"] = re.sub(r"_\d+\.\d\d\.\d\d\.\d+-\d+\.\d\d\.\d\d\.\d+\.", "_%s." % time_interval, fields["Id"])

mw.reviewer.card.note()["Audio"] = re.sub(r"_\d+\.\d\d\.\d\d\.\d+-\d+\.\d\d\.\d\d\.\d+\.", "_%s." % time_interval, fields["Audio"])

if "Video" in mw.reviewer.card.note():

mw.reviewer.card.note()["Video"] = re.sub(r"_\d+\.\d\d\.\d\d\.\d+-\d+\.\d\d\.\d\d\.\d+\.", "_%s." % time_interval, fields["Video"])

mw.reviewer.card.note().flush()

if VLC_DIR:

default_args = ["-I", "dummy", "--play-and-exit", "--no-video-title", "--video-on-top", "--sub-track=8"]

if is_win:

default_args += ["--dummy-quiet"]

default_args += ["--no-sub-autodetect-file"]

else:

default_args = ["--pause=no", "--script=%s" % os.path.join(os.path.dirname(os.path.abspath(__file__)), "settings.lua")]

default_args += ["--sub-visibility=no", "--no-resume-playback", "--save-position-on-quit=no"]

if path.endswith(".mp3"):

if VLC_DIR:

default_args += ["--no-video"]

else:

default_args += ["--force-window=no", "--video=no"]

args = list(default_args)

if state == None:

if VLC_DIR:

args += ["--start-time={}".format(time_start)]

if isEnd:

args += ["--stop-time={}".format(time_end)]

else:

args += ["--start={}".format(time_start)]

if isEnd:

args += ["--end={}".format(time_end)]

elif state == "start" or state == "start reset":

if VLC_DIR:

args += ["--start-time={}".format(time_start), "--stop-time={}".format(time_end)]

else:

args += ["--start={}".format(time_start), "--end={}".format(time_end)]

elif state == "end" or state == "end reset":

if VLC_DIR:

args += ["--start-time={}".format(time_end - ADJUST_AUDIO_REPLAY_TIME), "--stop-time={}".format(time_end)]

else:

args += ["--start={}".format(time_end - ADJUST_AUDIO_REPLAY_TIME), "--end={}".format(time_end)]

config = mw.addonManager.getConfig(__name__)

af_d = float(config["audio fade in/out"])

if (path.endswith(".mp3") and not isPrev and not isNext) or state != None:

if VLC_DIR:

pass

else:

if af_d:

args += ["--af=afade=t=out:st=%s:d=%s" % (time_end - af_d, af_d)]

else:

if VLC_DIR:

pass

else:

if not (state == None and isEnd == False):

if af_d:

args += ["--af=afade=t=out:st=%s:d=%s" % (time_end - af_d, af_d)]

if "Path" in fields and fields["Path"] != '':

fullpath = fields["Path"]

else:

try:

m = re.match(r"^(.*?)_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*$", fields["Id"])

video_id = m.group(1)

fullpath = media.get_path_in_media_db(video_id, ask=False)

except:

fullpath = path

if path is not None and os.path.exists(path) and isEnd == True and not any([state, isPrev, isNext]):

fullpath = path

args = list(default_args)

if not os.path.exists(fullpath):

if fullpath.endswith('.mp4') or fullpath.endswith('.webm'):

tooltip("video can't be found")

else:

tooltip("audio can't be found")

return

aid = "auto"

if fullpath != path:

try:

m = re.match(r"^(.*?)_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*$", fields["Id"])

video_id = m.group(1)

aid = media.getAudioId(video_id)

except:

pass

if VLC_DIR:

cmd = [VLC_DIR] + args + [os.path.normpath(fullpath)]

else:

if aid != "auto":

args += ["--aid={}".format(aid)]

else:

alang = config["preferred languages for audio"]

if alang != "":

args += ["--alang={}".format(alang)]

if is_mac and os.path.exists(IINA_DIR):

args = [o.replace("--", "--mpv-") for o in args]

cmd = [IINA_DIR] + args + [fullpath]

else:

cmd = [mpv_executable] + args + [fullpath]

if p != None and p.poll() is None:

p.kill()

if with_bundled_libs:

p = subprocess.Popen(cmd, cwd=mw.col.media.dir())

return

with no_bundled_libs():

if mw.state == "review" and mw.reviewer.card != None and (mw.reviewer.card.note_type()["name"] == "movies2anki (add-on)" or mw.reviewer.card.note_type()["name"].startswith("movies2anki - subs2srs")):

queueExternal(path)

else:

global p, _player

if mw.state == "review" and mw.reviewer.card != None and (mw.reviewer.card.note_type()["name"] == "movies2anki (add-on)" or mw.reviewer.card.note_type()["name"].startswith("movies2anki - subs2srs")):

# if mw.reviewer.state == "answer" and path.endswith(".mp4"):

# return

try:

clearExternalQueue()

oldcwd = os.getcwd()

os.chdir(mw.col.media.dir())

ret = playVideoClip(path.filename if av_player else path)

os.chdir(oldcwd)

if ret == False:

_player(path)

except OSError:

return showWarning(r"""<p>Please install <a href='https://mpv.io'>mpv</a>.</p>

On Windows download mpv and either update PATH environment variable or put mpv.exe in Anki installation folder (C:\Program Files\Anki).""", parent=mw)

else:

global p

if p != None and p.poll() is None:

global _queueEraser

_stopPlayer()

if mw.state == "review" and mw.reviewer.card != None and (mw.reviewer.card.note_type()["name"] == "movies2anki (add-on)" or mw.reviewer.card.note_type()["name"].startswith("movies2anki - subs2srs")):

try:

clearExternalQueue()

oldcwd = os.getcwd()

os.chdir(mw.col.media.dir())

playVideoClip(state=state, shift=shift)

os.chdir(oldcwd)

except OSError:

return showWarning(r"""<p>Please install <a href='https://mpv.io'>mpv</a>.</p>

global VLC_DIR

try:

if is_mac and os.path.exists(IINA_DIR):

return

if mpv_executable is None:

raise OSError()

if with_bundled_libs:

p = subprocess.Popen([mpv_executable, "--version"], startupinfo=info)

else:

with no_bundled_libs():

p = subprocess.Popen([mpv_executable, "--version"], startupinfo=info)

if p != None and p.poll() is None:

p.kill()

except OSError:

if VLC_DIR != "":

return

if is_win:

VLC_DIR = r"C:\Program Files\VideoLAN\VLC\vlc.exe"

if os.path.exists(VLC_DIR):

return

VLC_DIR = r"C:\Program Files (x86)\VideoLAN\VLC\vlc.exe"

if os.path.exists(VLC_DIR):

return

elif is_mac:

VLC_DIR = r"/Applications/VLC.app/Contents/MacOS/VLC"

if os.path.exists(VLC_DIR):

return

VLC_DIR = ""

return showWarning(r"""<p>Neither mpv nor VLC were found.</p>

<p>Please install <a href='https://mpv.io'>mpv</a>.</p>

if state != "review":

return

shortcuts.extend([

(",", lambda: adjustAudio("start", ADJUST_AUDIO_STEP)),

(".", lambda: adjustAudio("start", -1.0 * ADJUST_AUDIO_STEP)),

("Shift+,", lambda: adjustAudio("end", -1.0 * ADJUST_AUDIO_STEP)),

("Shift+.", lambda: adjustAudio("end", ADJUST_AUDIO_STEP)),

# ("Ctrl+Shift+,", lambda: adjustAudio("start reset")),

# ("Ctrl+Shift+.", lambda: adjustAudio("end reset")),

("Ctrl+R", replayVideo),

("Shift+R", lambda: replayVideo(isEnd=False)),

("[", lambda: replayVideo(isPrev=True)),

("]", lambda: replayVideo(isNext=True)),

("Shift+[", lambda: joinCard(isPrev=True)),

("Shift+]", lambda: joinCard(isNext=True)),

("б", lambda: adjustAudio("start", ADJUST_AUDIO_STEP)),

("ю", lambda: adjustAudio("start", -1.0 * ADJUST_AUDIO_STEP)),

("Shift+Б", lambda: adjustAudio("end", -1.0 * ADJUST_AUDIO_STEP)),

("Shift+Ю", lambda: adjustAudio("end", ADJUST_AUDIO_STEP)),

("х", lambda: replayVideo(isPrev=True)),

("ъ", lambda: replayVideo(isNext=True)),

("Shift+Х", lambda: joinCard(isPrev=True)),

("Shift+Ъ", lambda: joinCard(isNext=True)),

if mw.state == "review" and mw.reviewer.card != None and (mw.reviewer.card.note_type()["name"] == "movies2anki (add-on)" or mw.reviewer.card.note_type()["name"].startswith("movies2anki - subs2srs")):

clearExternalQueue()

oldcwd = os.getcwd()

os.chdir(mw.col.media.dir())

playVideoClip(isEnd=isEnd, isPrev=isPrev, isNext=isNext)

config = mw.addonManager.getConfig(__name__)

if mw.state == "review" and mw.reviewer.card != None and (mw.reviewer.card.note_type()["name"] == "movies2anki (add-on)" or mw.reviewer.card.note_type()["name"].startswith("movies2anki - subs2srs")):

audio_filename = mw.reviewer.card.note()["Audio"]

m = re.search(r'\[sound:(.+?)\]', audio_filename)

if m:

audio_filename = m.group(1)

audio_filename = audio_filename.replace('[sound:', '')

audio_filename = audio_filename.replace(']', '')

m = re.match(r"^(.*?)_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*$", audio_filename)

card_prefix, time_start, time_end = m.groups()

time_start = timeToSeconds(time_start)

time_end = timeToSeconds(time_end)

cards = sorted(mw.col.findCards('"Id:{}_*"'.format(card_prefix), order=True))

card_idx = cards.index(mw.reviewer.card.id)

prev_card_idx = card_idx - 1 if card_idx - 1 > 0 else 0

next_card_idx = card_idx + 1

if next_card_idx >= len(cards):

next_card_idx = len(cards) - 1

if (isPrev and mw.col.getCard(cards[prev_card_idx]).id == mw.reviewer.card.id) or \

(isNext and mw.col.getCard(cards[next_card_idx]).id == mw.reviewer.card.id):

tooltip("Nothing to do.")

return

curr_card = mw.col.getCard(cards[card_idx]).note()

prev_card = mw.col.getCard(cards[prev_card_idx]).note()

next_card = mw.col.getCard(cards[next_card_idx]).note()

prev_card_path = ''

curr_card_path = ''

next_card_path = ''

if "Path" in prev_card and prev_card["Path"] != "":

prev_card_path = prev_card["Path"]

else:

try:

m = re.match(r"^(.*?)_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*$", prev_card['Id'])

prev_card_path = media.get_path_in_media_db(m.group(1))

except:

return

if "Path" in curr_card and curr_card["Path"] != "":

curr_card_path = curr_card["Path"]

else:

try:

m = re.match(r"^(.*?)_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*$", curr_card['Id'])

curr_card_path = media.get_path_in_media_db(m.group(1))

except:

return

if "Path" in next_card and next_card["Path"] != "":

next_card_path = next_card["Path"]

else:

try:

m = re.match(r"^(.*?)_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*$", next_card['Id'])

next_card_path = media.get_path_in_media_db(m.group(1))

except:

return

if (isPrev and prev_card_path != curr_card_path) or (isNext and curr_card_path != next_card_path):

showInfo("Cards can't be joined due to the difference in Path.")

return

curr_card_audio = curr_card["Audio"]

prev_card_audio = prev_card["Audio"]

next_card_audio = next_card["Audio"]

m = re.match(r"^.*?_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*$", curr_card_audio)

curr_time_start, curr_time_end = m.groups()

curr_time_start = timeToSeconds(curr_time_start)

curr_time_end = timeToSeconds(curr_time_end)

m = re.match(r"^.*?_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*$", prev_card_audio)

prev_time_start, prev_time_end = m.groups()

prev_time_start = timeToSeconds(prev_time_start)

prev_time_end = timeToSeconds(prev_time_end)

m = re.match(r"^.*?_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*$", next_card_audio)

next_time_start, next_time_end = m.groups()

next_time_start = timeToSeconds(next_time_start)

next_time_end = timeToSeconds(next_time_end)

if isPrev:

time_start = prev_time_start

if isNext:

time_end = next_time_end

config = mw.addonManager.getConfig(__name__)

c = mw.reviewer.card.note()

for name, val in c.items():

if name == "Id":

c[name] = "%s_%s-%s" % (card_prefix, secondsToTime(time_start), secondsToTime(time_end))

elif name == "Audio":

c[name] = "%s_%s-%s.mp3" % (card_prefix, secondsToTime(time_start), secondsToTime(time_end))

elif name == "Video":

c[name] = "%s_%s-%s.%s" % (card_prefix, secondsToTime(time_start), secondsToTime(time_end), config['video extension'])

elif name == "Path":

pass

elif name == "Audio Sound":

c["Audio Sound"] = ""

elif name == "Video Sound":

c["Video Sound"] = ""

elif name == "Snapshot":

pass

else:

if isPrev:

c[name] = prev_card[name] + "<br>" + c[name]

else:

c[name] = c[name] + "<br>" + next_card[name]

mw.checkpoint(_("Delete"))

c.flush()

if isPrev:

cd = prev_card

else:

cd = next_card

cnt = len(cd.cards())

mw.col.remNotes([cd.id])

mw.reset()

tooltip(ngettext(

"Notes joined and %d card deleted.",

"Notes joined and %d cards deleted.",

updateProgress = pyqtSignal(int)

updateProgressText = pyqtSignal(str)

updateNote = pyqtSignal(str, str, str)

jobFinished = pyqtSignal(float)

def __init__(self, data, map_ids):

QThread.__init__(self)

self.data = data

self.canceled = False

self.fp = None

self.map_ids = map_ids

if os.environ.get("ADDON_DEBUG"):

logger.setLevel(logging.DEBUG)

def cancel(self):

self.canceled = True

if self.fp != None:

self.fp.terminate()

def run(self):

job_start = time.time()

mp3gain_executable = find_executable("mp3gain")

logger.debug('mpv_executable: {}'.format(mpv_executable))

config = mw.addonManager.getConfig(__name__)

for idx, note in enumerate(self.data):

if self.canceled:

break

self.updateProgress.emit((idx * 1.0 / len(self.data)) * 100)

fld = note["Audio"]

time_start, time_end = re.match(r"^.*?_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*$", fld).groups()

time_start_seconds = timeToSeconds(time_start)

time_end_seconds = timeToSeconds(time_end)

if time_start_seconds == time_end_seconds:

continue

ss = secondsToTime(timeToSeconds(time_start), sep=":")

se = secondsToTime(timeToSeconds(time_end), sep=":")

t = timeToSeconds(time_end) - timeToSeconds(time_start)

if config["audio fade in/out"]:

af_d = float(config["audio fade in/out"])

af_st = 0

af_to = t - af_d

default_af_params = "afade=t=in:st={:.3f}:d={:.3f},afade=t=out:st={:.3f}:d={:.3f}".format(af_st, af_d, af_to, af_d)

else:

default_af_params = ""

if "Path" in note and note["Path"] != "":

note_video_path = note["Path"]

else:

try:

m = re.match(r"^(.*?)_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*$", note["Id"])

video_id = m.group(1)

note_video_path = media.get_path_in_media_db(video_id)

except:

continue

audio_id = self.map_ids[note_video_path]

video_width = config["video width"]

video_height = config["video height"]

video_source = os.path.splitext(os.path.basename(note_video_path))[0]

self.updateProgressText.emit(video_source + " " + ss)

audio_filename = note["Audio"]

m = re.search(r'\[sound:(.+?)\]', audio_filename)

if m:

audio_filename = m.group(1)

audio_filename = audio_filename.replace('[sound:', '')

audio_filename = audio_filename.replace(']', '')

if os.path.exists(os.path.join(mw.col.media.dir(), audio_filename)):

if "Audio Sound" in note:

if '[sound:' not in note["Audio Sound"]:

self.updateNote.emit(str(note.id), "Audio Sound", "[sound:%s]" % audio_filename)

elif '[sound:' not in note["Audio"]:

self.updateNote.emit(str(note.id), "Audio", "[sound:%s]" % audio_filename)

af_params = default_af_params

if NORMALIZE_AUDIO and not (NORMALIZE_AUDIO_WITH_MP3GAIN and mp3gain_executable):

cmd = [ffmpeg_executable, "-ss", ss, "-i", note_video_path, "-t", str(t), "-af", "loudnorm=%s:print_format=json" % NORMALIZE_AUDIO_FILTER, "-f", "null", "-"]

logger.debug('normalize_audio: {}'.format('Started'))

logger.debug('normalize_audio: {}'.format(join_and_add_double_quotes(cmd)))

with no_bundled_libs():

output = check_output(cmd, startupinfo=info, encoding='utf-8')

logger.debug('normalize_audio: {}'.format('Finished'))

# https://github.com/slhck/ffmpeg-normalize/blob/5fe6b3df5f4b36b398fa08c11a9001b1e67cec10/ffmpeg_normalize/_streams.py#L171

output_lines = [line.strip() for line in output.split('\n')]

loudnorm_start = False

loudnorm_end = False

for index, line in enumerate(output_lines):

if line.startswith('[Parsed_loudnorm'):

loudnorm_start = index + 1

continue

if loudnorm_start and line.startswith('}'):

loudnorm_end = index + 1

break

stats = json.loads('\n'.join(output_lines[loudnorm_start:loudnorm_end]))

nf_params = "loudnorm={}:measured_I={}:measured_LRA={}:measured_TP={}:measured_thresh={}:offset={}:linear=true".format(NORMALIZE_AUDIO_FILTER, stats["input_i"], stats["input_lra"], stats["input_tp"], stats["input_thresh"], stats["target_offset"])

if af_params:

af_params = "%s,%s" % (nf_params, af_params)

else:

af_params = nf_params

if ("Audio Sound" in note and note["Audio Sound"] == "") or not os.path.exists(os.path.join(mw.col.media.dir(), audio_filename)):

self.fp = None

audio_temp_filepath = os.path.join(tmpdir(), audio_filename)

if ffmpeg_executable:

cmd = [ffmpeg_executable, "-y", "-ss", ss, "-i", note_video_path, "-loglevel", "quiet", "-t", "{:.3f}".format(t)]

if af_params:

cmd += ["-af", af_params]

cmd += ["-sn"]

cmd += ["-map_metadata", "-1"]

if audio_filename.endswith('.mp3'):

cmd += ["-c:a", "libmp3lame"]

cmd += ["-map", "0:a:{}".format(audio_id-1)]

cmd += [audio_temp_filepath]

else:

cmd = [mpv_executable, note_video_path]

# cmd += ["--include=%s" % self.mpvConf]

cmd += ["--start=%s" % ss, "--length=%s" % "{:.3f}".format(t)]

cmd += ["--aid=%d" % (audio_id)]

cmd += ["--video=no"]

cmd += ["--no-ocopy-metadata"]

cmd += ["--af=afade=t=in:st={:.3f}:d={:.3f},afade=t=out:st={:.3f}:d={:.3f}".format(time_start_seconds, af_d, time_end_seconds - af_d, af_d)]

cmd += ["--o=%s" % audio_temp_filepath]

logger.debug('export_audio: {}'.format('Started'))

logger.debug('export_audio: {}'.format(join_and_add_double_quotes(cmd)))

if with_bundled_libs:

self.fp = subprocess.Popen(cmd, startupinfo=info, cwd=mw.col.media.dir())

self.fp.wait()

else:

with no_bundled_libs():

self.fp = subprocess.Popen(cmd, startupinfo=info, cwd=mw.col.media.dir())

self.fp.wait()

logger.debug('export_audio: {}'.format('Finished'))

if NORMALIZE_AUDIO and NORMALIZE_AUDIO_WITH_MP3GAIN and mp3gain_executable:

cmd = [mp3gain_executable, "/f", "/q", "/r", "/k", audio_temp_filepath]

with no_bundled_libs():

self.fp = subprocess.Popen(cmd, startupinfo=info, cwd=mw.col.media.dir())

self.fp.wait()

if self.canceled:

break

if os.path.exists(audio_temp_filepath):

with open(audio_temp_filepath, "rb") as file:

fdata = file.read()

mw.col.media.write_data(audio_filename, fdata)

if "Audio Sound" in note:

self.updateNote.emit(str(note.id), "Audio Sound", "[sound:%s]" % audio_filename)

else:

self.updateNote.emit(str(note.id), "Audio", "[sound:%s]" % audio_filename)

video_filename = ""

if "Video" in note:

video_filename = note["Video"]

m = re.search(r'\[sound:(.+?)\]', video_filename)

if m:

video_filename = m.group(1)

video_filename = video_filename.replace('[sound:', '')

video_filename = video_filename.replace(']', '')

if os.path.exists(os.path.join(mw.col.media.dir(), video_filename)):

if "Video Sound" in note:

if '[sound:' not in note["Video Sound"]:

self.updateNote.emit(str(note.id), "Video Sound", "[sound:%s]" % video_filename)

elif '[sound:' not in note["Video"]:

self.updateNote.emit(str(note.id), "Video", "[sound:%s]" % video_filename)

if ("Video Sound" in note and (note["Video Sound"] == "") or (video_filename != "" and not os.path.exists(os.path.join(mw.col.media.dir(), video_filename)))):

self.fp = None

video_temp_filepath = os.path.join(tmpdir(), video_filename)

if ffmpeg_executable:

cmd = [ffmpeg_executable, "-y", "-ss", ss, "-i", note_video_path, "-loglevel", "quiet", "-t", "{:.3f}".format(t)]

if af_params:

cmd += ["-af", af_params]

cmd += ["-map", "0:v:0", "-map", "0:a:{}".format(audio_id-1), "-ac", "2", "-vf", "scale='min(%s,iw)':'min(%s,ih)',setsar=1" % (video_width, video_height)]

cmd += ["-pix_fmt", "yuv420p"]

cmd += ["-sn"]

cmd += ["-map_metadata", "-1"]

if video_filename.endswith('.webm'):

cmd += config["video encoding settings (webm)"].split()

else:

cmd += ["-c:v", "libx264"]

cmd += ["-profile:v", "main", "-level:v", "3.1"]

cmd += ['-movflags', '+faststart']

cmd += [video_temp_filepath]

else:

cmd = [mpv_executable, note_video_path]

# cmd += ["--include=%s" % self.mpvConf]

cmd += ["--start=%s" % ss, "--length=%s" % "{:.3f}".format(t)]

cmd += ["--sub=no"]

cmd += ["--no-ocopy-metadata"]

cmd += ["--aid=%d" % (audio_id)]

cmd += ["--af=afade=t=in:st={:.3f}:d={:.3f},afade=t=out:st={:.3f}:d={:.3f}".format(time_start_seconds, af_d, time_end_seconds - af_d, af_d)]

cmd += ["--vf-add=lavfi=[scale='min(%s,iw)':'min(%s,ih)',setsar=1]" % (video_width, video_height)]

if video_filename.endswith('.webm'):

cmd += ["--ovc=libvpx-vp9"]

cmd += ["--ovcopts=b=1400K,threads=4,crf=23,qmin=0,qmax=36,speed=2"]

else:

cmd += ["--ovc=libx264"]

cmd += ["--ovcopts=profile=main,level=31"]

cmd += ["--vf-add=format=yuv420p"]

cmd += ["--oac=aac"]

cmd += ["--ofopts=movflags=+faststart"]

cmd += ["--o=%s" % video_temp_filepath]

logger.debug('export_video: {}'.format('Started'))

logger.debug('export_video: {}'.format(join_and_add_double_quotes(cmd)))

if with_bundled_libs:

self.fp = subprocess.Popen(cmd, startupinfo=info, cwd=mw.col.media.dir())

self.fp.wait()

else:

with no_bundled_libs():

self.fp = subprocess.Popen(cmd, startupinfo=info, cwd=mw.col.media.dir())

self.fp.wait()

logger.debug('export_video: {}'.format('Finished'))

retcode = self.fp.returncode

logger.debug('return code: {}'.format(retcode))

if retcode != 0 and not self.canceled:

cmd_debug = ' '.join(['"' + c + '"' for c in cmd])

cmd_debug = cmd_debug.replace(' "-loglevel" "quiet" ', ' ')

cmd_debug = [cmd_debug]

raise CalledProcessError(retcode, cmd_debug)

if self.canceled:

break

if os.path.exists(video_temp_filepath):

with open(video_temp_filepath, "rb") as file:

fdata = file.read()

mw.col.media.write_data(video_filename, fdata)

if "Video Sound" in note:

self.updateNote.emit(str(note.id), "Video Sound", "[sound:%s]" % video_filename)

else:

self.updateNote.emit(str(note.id), "Video", "[sound:%s]" % video_filename)

job_end = time.time()

time_diff = (job_end - job_start)

if not self.canceled:

self.updateProgress.emit(100)

global is_cancel

is_cancel = True

if hasattr(mw, 'worker'):

mw.worker.cancel()

del mw.worker

if hasattr(mw, 'progressDialog'):

mw.progressDialog.cancel()

mw.progressDialog.done(0)

minutes = int(time_diff / 60)

seconds = int(time_diff % 60)

message = "Processing completed in %s minutes %s seconds." % (minutes, seconds)

if not errors:

QMessageBox.information(parent, "movies2anki", message)

else:

msg = "The following notes were skipped because the Id field doesn't match the regular expression: ^(.*?)_(\d+\.\d\d\.\d\d\.\d+)-(\d+\.\d\d\.\d\d\.\d+).*$"

msg += "\n"

msg += "\n"

msg += ' or '.join(['nid:{}'.format(str(e)) for e in errors])

def __init__(self, map_ids, map_data, parent=None):

super(AudioInfo, self).__init__(parent)

self.map_data = map_data

self.map_ids = map_ids

self.initUI()

def initUI(self):

okButton = QPushButton("OK")

okButton.clicked.connect(self.ok)

vbox = QVBoxLayout()

hbox = QHBoxLayout()

grid = QGridLayout()

grid.setSpacing(10)

# grid.addWidget(reviewEdit, 1, 1, 1, 3)

hbox.addStretch(1)

hbox.addWidget(okButton)

for idx, video_path in enumerate(self.map_data):

video_filename = os.path.basename(video_path)

audio_tracks = self.map_data[video_path]

i_selected = 0

btn_label = QLabel(video_filename)

btn_cbox = QComboBox()

# btn_cbox.setSizeAdjustPolicy(QComboBox.SizeAdjustPolicy.AdjustToContents)

for i in audio_tracks:

title = audio_tracks[i]['title']

if title == '(unavailable)':

title = ''

lang = audio_tracks[i]['lang']

if not lang:

lang = 'und'

if audio_tracks[i]['selected'] == 'yes':

self.map_ids[video_path] = i

i_selected = i - 1

item_title = '{}: {}'.format(i, lang)

if title:

item_title += ' ({})'.format(title)

btn_cbox.addItem(item_title)

btn_cbox.setCurrentIndex(i_selected)

btn_cbox.currentIndexChanged.connect(lambda x, vp=video_path: self.setAudioStream(vp, x))

grid.addWidget(btn_label, idx + 1, 1)

grid.addWidget(btn_cbox, idx + 1, 2)

grid.setColumnStretch(1,1)

grid.setRowMinimumHeight(len(self.map_data)+1, 30)

vbox.addLayout(grid)

vbox.addLayout(hbox)

self.setLayout(vbox)

self.setWindowTitle('[movies2anki] Select Audio Streams')

self.setModal(True)

# self.setMinimumSize(400, 300)

self.adjustSize()

self.setMinimumWidth(450)

def setAudioStream(self, video_path, i):

self.map_ids[video_path] = i+1

def ok(self):

self.done(1)

def cancel(self):

if filter != "play":

return text

if '[sound:' in text:

return text

text = text.strip()

if text == '':

return text

"movies2anki (add-on)",

"movies2anki - subs2srs (image)",

"movies2anki - subs2srs (video)",

"movies2anki - subs2srs (audio)"

nids = []