def test_issue_470():
audio_clip = AudioFileClip("media/crunching.mp3")
# end_time is out of bounds
subclip = audio_clip.subclip(start_time=6, end_time=9)
with pytest.raises(IOError):
subclip.write_audiofile(os.path.join(TMP_DIR, "issue_470.wav"),
write_logfile=True)
# but this one should work..
subclip = audio_clip.subclip(start_time=6, end_time=8)
subclip.write_audiofile(os.path.join(TMP_DIR, "issue_470.wav"),
write_logfile=True)
def run(self, outputVideoName):
# 对加速点迭代加速
BgmName = 'BGM/model2-BGM.wav'
for breakPoint in self.breakPoints:
print(' *' * 12, '正在处理:', breakPoint, ' *' * 12)
END = self.clip.end
clipFirst = self.clip.subclip(self.START,
breakPoint - self.M / self.speedRate)
clipMiddle = speedx(self.clip.subclip(
breakPoint - self.M / self.speedRate,
breakPoint - self.M / self.speedRate + self.M),
factor=self.speedRate)
clipLast = self.clip.subclip(
breakPoint - self.M / self.speedRate + self.M, END)
self.clip = concatenate_videoclips(
[clipFirst, clipMiddle, clipLast])
length = 0
sound = AudioFileClip(BgmName)
if self.clip.end < sound.end:
length = self.clip.end
sound = sound.subclip(0, length)
else:
length = sound.end
self.clip = self.clip.subclip(0, length)
self.clip = self.clip.set_audio(sound)
self.clip.fps = 30
self.writeClip(outputVideoName)
def test_audio_coreader():
if sys.platform.startswith("win"):
pytest.skip("Temporarily skipping on windows because otherwise test suite fails with Invalid Handle Error")
sound = AudioFileClip("media/crunching.mp3")
sound = sound.subclip(1, 4)
sound2 = AudioFileClip("media/crunching.mp3")
sound2.write_audiofile(os.path.join(TMP_DIR, "coreader.mp3"))
def test_audiofileclip_concat():
sound = AudioFileClip("media/crunching.mp3")
sound = sound.subclip(1, 4)
# Checks it works with videos as well
sound2 = AudioFileClip("media/big_buck_bunny_432_433.webm")
concat = concatenate_audioclips((sound, sound2))
concat.write_audiofile(os.path.join(TMP_DIR, "concat_audio_file.mp3"))
def test_audiofileclip_concat():
sound = AudioFileClip("media/crunching.mp3")
sound = sound.subclip(1, 4)
# Checks it works with videos as well
sound2 = AudioFileClip("media/big_buck_bunny_432_433.webm")
concat = concatenate_audioclips((sound, sound2))
concat.write_audiofile(os.path.join(TMP_DIR, "concat_audio_file.mp3"))
def test_audio_coreader():
if sys.platform.startswith("win"):
pytest.skip(
"Temporarily skipping on windows because otherwise test suite fails with Invalid Handle Error"
)
sound = AudioFileClip("media/crunching.mp3")
sound = sound.subclip(1, 4)
sound2 = AudioFileClip("media/crunching.mp3")
sound2.write_audiofile(os.path.join(TMP_DIR, "coreader.mp3"))
class VideoGenerator:
def __init__(self, path_to_video, max_length: timedelta, out_path, title):
self.audio = AudioFileClip(path_to_video)
self.max_length = max_length
self.out_path = out_path
self.title = title
def generate_from_scenes(self, scenes: List[Scene], fps):
clips = []
total_duration = 0
for scene in scenes:
clip = self._generate_from_scene(scene, fps)
total_duration += clip.duration
if total_duration > self.max_length.seconds:
break
clips.append(clip)
if clips:
if self.title:
title_clip = TextClip(self.title,
color='white',
bg_color='black',
fontsize=60,
size=(clips[0].w,
clips[0].h)).set_duration(5)
clips.append(title_clip)
trailer = concatenate_videoclips(clips)
if os.path.exists(self.out_path):
os.remove(self.out_path)
trailer.write_videofile(self.out_path)
def _generate_from_scene(self, scene, fps) -> ImageSequenceClip:
return self._generate_from_frames(scene.frames, fps)
def _generate_from_frames(self, frames: List[Frame], fps):
images = []
for f in frames:
images.append(f.image)
clip = ImageSequenceClip(images, fps=fps)
audio_clip = self.audio.subclip(frames[0].timestamp,
frames[-1].timestamp)
new_clip = clip.set_audio(audio_clip)
return new_clip
def test_audiofileclip_concat():
if sys.platform.startswith("win"):
pytest.skip("Temporarily skipping on windows because otherwise test suite fails with Invalid Handle Error")
sound = AudioFileClip("media/crunching.mp3")
sound = sound.subclip(1, 4)
# Checks it works with videos as well
sound2 = AudioFileClip("media/big_buck_bunny_432_433.webm")
concat = concatenate_audioclips((sound, sound2))
concat.write_audiofile(os.path.join(TMP_DIR, "concat_audio_file.mp3"))
def test_audiofileclip_concat():
if sys.platform.startswith("win"):
pytest.skip(
"Temporarily skipping on windows because otherwise test suite fails with Invalid Handle Error"
)
sound = AudioFileClip("media/crunching.mp3")
sound = sound.subclip(1, 4)
# Checks it works with videos as well
sound2 = AudioFileClip("media/big_buck_bunny_432_433.webm")
concat = concatenate_audioclips((sound, sound2))
concat.write_audiofile(os.path.join(TMP_DIR, "concat_audio_file.mp3"))
def AVsync(audio_fn, video_fn, offset=None, verbose=False):
audio = AudioFileClip(audio_fn)
video = VideoFileClip(video_fn)
if offset is None:
x1 = audio.to_soundarray()
x2 = video.audio.to_soundarray()
offset, corr = calculate_time_offset(x1[:, 0], x2[:, 0], fs=44100)
if verbose:
print(f"Offset: {offset:2.3f}s\nCorrelation: {corr*100:2.2f}%")
if offset > 0:
video_out = video.set_audio(audio.subclip(offset))
else:
video_out = video.subclip(-offset).set_audio(audio)
return video_out
def run(self, workStation, outputVideoName):
length = 0
BgmName = 'BGM/model1-BGM.wav'
imgs = get_imgFile(str(workStation) + '/imgs')
# 截取使img和durations同等长度
if len(imgs) != len(self.durations):
length = min(len(imgs), len(self.durations))
self.durations = self.durations[0:length]
imgs = imgs[0:length]
# 将视频和BGM也截取相同的长度
self.clip = ImageSequenceClip(imgs, durations=durations)
sound = AudioFileClip(BgmName)
if self.clip.end < sound.end:
length = self.clip.end
sound = sound.subclip(0, length)
else:
length = sound.end
self.clip = self.clip.subclip(0, length)
self.clip = self.clip.set_audio(sound)
self.clip.fps = 30
self.writeClip(str(workStation) + '/' + outputVideoName)
def test_audio_coreader():
sound = AudioFileClip("media/crunching.mp3")
sound = sound.subclip(1, 4)
sound2 = AudioFileClip("media/crunching.mp3")
sound2.write_audiofile(os.path.join(TMP_DIR, "coreader.mp3"))
def test_audio_coreader():
sound = AudioFileClip("media/crunching.mp3")
sound = sound.subclip(1, 4)
sound2 = sound.coreader()
sound2.write_audiofile(os.path.join(TMP_DIR, "coreader.mp3"))
def genPMVs(PMV, dot, sampleHeight, sampleWidth, pythonDir):
# file
# outDir
ydl_opts = {
'outtmpl': PMV.musicDir + '%(title)s' + '.mp4',
'format': 'best',
'playlist': 'no'
}
with youtube_dl.YoutubeDL(ydl_opts) as ydl:
ydl.cache.remove()
info_dict = ydl.extract_info(PMV.musicURL, download=False)
print('downloading?', PMV.musicURL)
ydl.download([PMV.musicURL])
musicName = info_dict.get('title', None)
for vid in PMV.videoURLs:
print(vid)
subprocess.call([pythonDir, r"downloadVid.py", PMV.vidDir, vid])
vidDir = PMV.vidDir
if PMV.musicType == 'mp4':
originalVidBool = True
elif PMV.musicType == 'mp3':
originalVidBool = False
else:
originalVidBool = False
print(AudioSegment.ffmpeg)
################################
mp3_dir = PMV.musicDir + musicName + dot + 'mp4' # PMV.musicType
###############################
if len(PMV.vidName) == 0:
PMV.vidName = PMV.userName + ' PMV - ' + musicName
elif len(PMV.userName) > 0:
PMV.vidName = PMV.vidName + ' - ' + PMV.userName
file_out = PMV.outDir + PMV.vidName + dot + 'mp4' # filetypeout
print(mp3_dir)
audioclip = AudioFileClip(mp3_dir)
print('error1')
sound = AudioSegment.from_file(mp3_dir, 'mp4')
print('error2')
if PMV.trimSong == True:
sound = sound[PMV.songStart * 1000:PMV.songEnd * 1000]
audioclip = audioclip.subclip(PMV.songStart, PMV.songEnd)
print('error3')
tenSecs = 10 * 1000
first_10_seconds = sound[:tenSecs]
ten_data = first_10_seconds._data
first_ten_data = np.fromstring(ten_data, dtype=np.int16)
new_ten_data = np.absolute(first_ten_data)
# %% Music Data
bitrate = len(new_ten_data) / 10 # raw data to 1 s
print(bitrate)
ratio = int(round(bitrate * PMV.granularity, 0))
raw_data = sound._data
first_data = np.fromstring(raw_data, dtype=np.int16)
new_data = np.absolute(first_data)
reshaped_data = reshapeData(new_data, ratio)
diff_data = getElementDiff(reshaped_data)
result = getHighValues2(reshaped_data, diff_data, PMV.sd_scale,
PMV.nSplits, PMV.granularity, PMV.min_length)
print('List of Indices of maximum element :', len(result))
print(result)
print(vidDir)
result.append(len(first_data) / ratio)
videosIn = list()
iVids = 0
for f in listdir(vidDir):
if isfile:
if f.endswith(".mp4"):
if iVids < 120:
videosIn.append(f)
iVids = iVids + 1
videoData = list()
for i in videosIn:
videoData.append(
Video(name=i, customStart=0, customEnd=0, directory=vidDir))
print(i)
nInVids = len(videosIn)
iOrig = 0
origVidName = musicName + dot + PMV.musicType
if originalVidBool == True:
while iOrig <= nInVids * PMV.origVidScale:
videoData.append(
Video(name=origVidName,
customStart=0,
customEnd=0,
directory=PMV.musicDir))
iOrig = iOrig + 1
nVideos = len(videoData)
videos = [0] * nVideos
i = 0
while i < nVideos:
if PMV.resize == True:
vidTemp = VideoFileClip(
videoData[i].directory + videoData[i].name).resize(
width=sampleWidth) #(sampleWidth, sampleHeight))
if PMV.flipBool == True and videoData[i].name != origVidName:
vidTemp2 = mirror_x(vidTemp)
else:
vidTemp2 = vidTemp
videos[i] = vidTemp2
else:
videos[i] = VideoFileClip(vidDir + videoData[i].name)
print('name', 'duration', 'customStart', 'customEnd')
if originalVidBool == True and videoData[i].name == origVidName:
if PMV.trimSong == True:
videoData[i].customEnd = PMV.songEnd
videoData[i].customStart = PMV.songStart
else:
videoData[i].customEnd = videos[i].duration
videoData[i].customStart = 0 #
print(videoData[i].name, videos[i].duration,
videoData[i].customStart, videoData[i].customEnd,
'Original Video')
else:
customStart = PMV.startTime
subtractEnd = 40
videoData[i].customEnd = videos[i].duration - subtractEnd
videoData[i].customStart = customStart
print(videoData[i].name, videos[i].duration,
videoData[i].customStart, videoData[i].customEnd)
i = i + 1
clips = videoSplits(result, videos, videoData, first_data, bitrate,
PMV.granularity, PMV.randomise, origVidName)
for attempt in range(3):
try:
print('stage 1')
finalVideo = concatenate_videoclips(clips, method='compose')
if PMV.originalCrop == True:
(w, h) = finalVideo.size
print(PMV.origCropFrac, int(sampleHeight * PMV.origCropFrac),
int((1 - PMV.origCropFrac) * sampleHeight), w, h)
finalVideo = finalVideo.crop(height=int(
round((1 - PMV.origCropFrac * 2) * sampleHeight, 0)),
width=w,
x_center=w / 2,
y_center=h / 2)
print('stage 2')
finalVideo.volumex(0)
print('stage 3')
finalVideo2 = finalVideo.set_audio(audioclip)
print('stage 4')
finalVideo2a = fadeout(finalVideo2, 1, final_color=None)
finalVideo2c = fadein(finalVideo2a, 1, initial_color=None)
if PMV.addIntro:
introVideo = getIntroVid(PMV.vidName, PMV.origCropFrac,
sampleHeight, PMV.introVidDir,
PMV.userName)
finalVideo3 = concatenate_videoclips(
[introVideo, finalVideo2c], method='compose')
else:
finalVideo3 = finalVideo2c
print('stage 4')
print('stage 5')
finalVideo3.write_videofile(file_out, threads=4, fps=25)
except OSError as OSErrorMessage:
print("OSError retrying - Attempt: ", attempt)
print(OSErrorMessage)
pass
else:
break
print('stage 6')
i = 0
while i < len(videos):
videos[i].reader.close()
del videos[i].reader
del videos[i]
i = i + 1
del audioclip.reader
del audioclip
print('Finished!')
