def encoder(bin_path, out_path, time_lim, width, highth):
fra = 5
pixel_size = 20
bin_in = db.dec2bin(bin_path)
x = len(bin_in)
row_num = int(highth / pixel_size)
col_num = int(width / pixel_size / 8)
y = int(x // (row_num * col_num)) #生成的图片数
if (y > time_lim * fra):
y = time_lim * fra
for i in range(y):
m = i * row_num * col_num
n = (i + 1) * row_num * col_num
bin_slice = bin_in[m:n]
img = np.zeros((highth, width), dtype=np.uint8)
for j in range(row_num):
img[j * pixel_size:(j + 1) * pixel_size, 0:width] = db.made_row(
bin_slice[j * col_num:(j + 1) * col_num], pixel_size, width)
im = Image.fromarray(img)
im.save(str(i) + ".png")
ff = FFmpeg(inputs={'': '-f image2 -r ' + str(fra) + ' -i %d.png'},
outputs={out_path: '-vcodec mpeg4'})
print(ff.cmd)
ff.run()
return y
def Mp3ToWav(input_path, output_path):
if input_path.endswith('.mp3') is not True:
raise Exception('Input is not mp3 file!')
if output_path.endswith('.wav') is not True:
raise Exception('Output is not wav file!')
ff = FFmpeg(inputs={input_path: '-y'}, outputs={output_path: None})
ff.run()
def play():
path = 'reply.wav' # 文件路径
if os.path.exists(path): # 如果文件存在
# 删除文件，可使用以下两种方法。
os.remove(path)
# os.unlink(path)
else:
print('no such file:%s') # 则返回文件不存在
ff = FFmpeg(
executable=
'C:\\Users\\86158\\Downloads\\ffmpeg-N-100493-gc720286ee3-win64-lgpl-vulkan\\bin\\ffmpeg.exe',
inputs={
r'D:\pythonProject\SpeechRecognition\demo.pcm':
"-f s16le -ar 16000 -ac 1"
},
outputs={r'D:\pythonProject\SpeechRecognition\reply.wav': ""})
print(ff.cmd)
ff.run()
wf = wave.open("reply.wav", 'rb')
p = pyaudio.PyAudio()
stream = p.open(format=p.get_format_from_width(wf.getsampwidth()),
channels=wf.getnchannels(),
rate=wf.getframerate(),
output=True)
data = wf.readframes(1024)
while data != b'':
stream.write(data)
data = wf.readframes(1024)
stream.stop_stream()
stream.close()
p.terminate()
def video_to_frames(viedo_file):
# 创建存储视频原始帧序列文件夹
os.mkdir("test_origin")
# 执行ffmpeg命令，30对应帧数
ff = FFmpeg(inputs={viedo_file: None}, outputs={
'test_origin/%04d.jpg': ['-r', '30', '-qscale:v', '2']})
ff.run()
def flv_concat(flv_list_dir, output_dir):
# 不加safe参数报错，-v quiet不显示处理过程，-y覆盖已存在
ff = FFmpeg(global_options="-f concat -safe 0 ",
inputs={str(flv_list_dir): None},
outputs={output_dir + '.flv': "-c copy -v quiet -y"})
# print(ff.cmd)
ff.run()
def click_DownButton():
#根据视频编号下载视频
#手机号
video_number = int(down_entry.get())
if video_number < 0:
downlistbox.insert(tk.END, "错误\n请选择正确编号")
return
if video_number >= len(videoList):
downlistbox.insert(tk.END, "错误\n请选择正确编号")
return
#获得.py所在的文件夹的绝对路径
dic = videoList[video_number]
url = dic['url']
if 'xiaoka.tv' in url:
downlistbox.insert(tk.END, 'xiaoka.tv 视频')
elif 'http://cychengyuan-vod.48.cn' in url:
url = url.replace('http://', 'https://')
else:
downlistbox.insert(tk.END, "url错误 下载失败")
return
name = dic['title'] + '_' + dic['time']
py_file_path = os.path.dirname(os.path.abspath(__file__))
file_path = py_file_path + '/' + name + '.mp4'
ff = FFmpeg(inputs={url: None},
outputs={file_path: '-c copy -bsf:a aac_adtstoasc'})
print(ff.cmd)
try:
ff.run_async()
downlistbox.insert(tk.END, "请等待下载完成")
except:
downlistbox.insert(tk.END, "ffmpeg错误\n下载失败")
def avi2mp4(source_path: str, target_path: str):
print("start transformation")
ff = FFmpeg(inputs={source_path: '-f avi'},
outputs={target_path: '-f mp4 -y'})
print(ff.cmd)
ff.run()
print("finish transformation")
def videocilp_wav():
output_clip_dir = r'C:/output_clip' # 已输出片段路径
wav_path_dir = r'C:/output_audio' # 待转换音频输出的路径
file_Suffix = ['.mp4', '.MP4']
wav_file_names = [
name for name in os.listdir(output_clip_dir)
for item in file_Suffix if os.path.splitext(name)[1] == item
]
for j in range(len(wav_file_names)):
videocilp_name = output_clip_dir + "/" + wav_file_names[j]
wav_output_file = wav_path_dir + "/" + wav_file_names[
j].replace('.MP4', '.wav')
probe = ffmpeg.probe(videocilp_name)
audio_stream = next((stream for stream in probe['streams']
if stream['codec_type'] == 'audio'), None)
if audio_stream is None:
print('No audio stream found', file=sys.stderr)
else:
aa = FFmpeg(inputs={videocilp_name: None},
outputs={
wav_output_file:
'-y -vn -ar 16000 -ab 192 -ac 1 -f wav'
})
print(aa.cmd)
aa.run()
print('转换完成')
def WavToPcm(input_path, output_path):
if input_path.endswith('.wav') is not True:
raise Exception('Input is not wav file!')
if output_path.endswith('.pcm') is not True:
raise Exception('Output is not pcm file')
ff = FFmpeg(inputs={input_path: '-y'},
outputs={output_path: '-f s16le -ac 1 -ar 16000'})
ff.run()
def mp4_handler(video_path, audio_path, output_dir):
ff = FFmpeg(
inputs={
str(video_path): None,
str(audio_path): None
},
outputs={str(output_dir + '.mp4'): '-c:v h264 -c:a ac3 -v quiet -y'})
# print(ff.cmd)
ff.run()
def processStreams(self, aFile1, aFile2, aDir):
idx = self.fname.rfind('.')
outFileName = self.fname[:idx] + '.mp4'
ff = FFmpeg(inputs={
aDir + '\\' + aFile1: None,
aDir + '\\' + aFile2: None
},
outputs={aDir + '\\' + outFileName: None})
ff.run()
def merger(audioinput, videoinput):
path=settings.MEDIA_ROOT+"/temp"
input_file=location+"/"+files
audio_file=audioinput
output_file=path+"/"+"media/"+"/save"+"/"+comment.video_file.url[13::]
'''COMMAND FOR MERGE AUDIO AND VIDEO FILES'''
com_file = FFmpeg(inputs={input_file: None,audio_file:None},outputs={output_file: '-shortest'})
com_file.run()
return output_file
def run_myffmpeg(dict_in, out_path):
inputs_list = get_inputs_list(dict_in)
filter_a = get_filter_expression(dict_in, inputs_list=inputs_list)
dict_inputs = get_inputs_dict(dict_in, inputs_list)
dict_outputs = get_outputs_dict(out_path, filter_a, dict_in['duration'])
ff = FFmpeg(inputs=dict_inputs, outputs=dict_outputs)
print(ff.cmd)
ff.run()
return ff.cmd
def transcoding_video(self, input_file, output_file):
""" 视频转码，mpeg4转为h264"""
# print(44444444444444, output_file)
if os.path.isfile(output_file):
# 把原来的视频删掉，不然后续FFmpeg转码时，会报 File 'M:\demo\AT2\media\ui\c6a54e8c962fffe261a21621be455512.mp4' already exists. Overwrite ? [y/N] Not overwriting - exiting
self.remove_file(output_file)
ff = FFmpeg(inputs={input_file: None}, outputs={output_file: None})
# print(111111111111111111111, ff.cmd)
ff.run()
def extract_audio_from_video(video, output_audio):
"""
从视频中提取音频
:param video: 视频文件
:param output_audio: 提取到的音频文件
:return:
"""
ff = FFmpeg(inputs={video: None},
outputs={output_audio: "-vn -ar 44100 -ac 2 -ab 192 -f wav"})
ff.run()
def get_devices():
string = open("fff.txt", "w")
ff = FFmpeg(inputs={'dummy': "-list_devices true -f dshow"}, )
try:
stdout, stderr = ff.run(stderr=string)
except:
pass
string.close()
string = open("fff.txt", "r", encoding="utf-8")
return filter.filter(string.read())
def ffmpeg_path(inputs_path, outputs_path):
'''
:param inputs_path: 输入的文件传入字典格式{文件：操作}
:param outputs_path: 输出的文件传入字典格式{文件：操作}
:return:
'''
a = FFmpeg(inputs={inputs_path: None}, outputs={
outputs_path: '-c copy',
})
print(a.cmd)
a.run()
def asciipic_to_video():
if os.path.exists("video_result"):
pass
else:
os.mkdir("video_result")
# 执行ffmpeg命令，30对应帧数
ff = FFmpeg(inputs={'test_out/%04d_ascii.jpg': None}, outputs={
'./video_result/test_out.mp4': ['-c:v', 'libx264', '-vf', 'fps=30', '-pix_fmt', 'yuv420p']})
ff.run()
def merge(self, num: str):
ff = FFmpeg(inputs={
f'{self.path}/src/{num}.mp4': None,
f'{self.path}/src/{num}.mp3': None,
},
outputs={
f'{self.path}/dst/{self.maps[num]["title"]}.mp4':
'-c:v h264 -c:a ac3'
})
ff.run()
print("merge completed", self.maps[num]["title"])
def video2wav(file):
input_file = file
extension = file.split('.')[-1]
path, filename = os.path.split(input_file)
output_file = 'Audio/' + filename.replace(extension, 'wav')
ff = FFmpeg(inputs={input_file: None},
global_options=['-y'],
outputs={output_file: '-vn -ar 16000 -ac 1 -ab 128k -f wav'})
print(ff.cmd)
ff.run()
return output_file
def vedio_to_wav(file):
inputfile = file
file_type = file.split('.')[-1]
outputfile = inputfile.replace(file_type, 'wav')
ff = FFmpeg(executable='ffmpeg',
global_options=['-y'],
inputs={inputfile: None},
outputs={outputfile: None})
ff.cmd
ff.run()
return outputfile
def vedio_to_pcm(file):
inputfile = file
file_type = file.split('.')[-1]
outputfile = inputfile.replace(file_type, 'pcm')
ff = FFmpeg(
executable='ffmpeg',
global_options=['-y'],
inputs={inputfile: None},
outputs={outputfile: '-acodec pcm_s16le -f s16le -ac 1 -ar 16000'})
ff.cmd
ff.run()
return outputfile
def post(self, request, format='json'):
if not request.POST._mutable:
request.POST._mutable = True
data = request.data
temp_delete()
data['status'] = True
data['user'] = request.user.id
video_file=request.FILES["video_file"]
fs = FileSystemStorage(location='static/media/temp/') #defaults to MEDIA_ROOT
filename = fs.save(video_file.name,video_file )
audio_id=request.data["audiofile"]
path=settings.MEDIA_ROOT[0:52]
'''FETCH AUDIO FILE'''
audio_file=AudioFile.objects.filter(id=audio_id)
for i in audio_file:
audio=i.audio_file.url
audio1=path+audio
'''FETCH TEMPORARY VIDEO FILES'''
store=settings.MEDIA_ROOT+"temp"
for files in os.listdir(store):
input_file=store+"/"+files
audio_file=audio1
output_file=path+"/"+"media/"+"save"+"/"+"merge_"+files
'''COMMAND FOR MERGE AUDIO AND VIDEO FILES'''
com_file = FFmpeg(inputs={input_file: None,audio_file:None},outputs={output_file: '-shortest'})
com_file.run()
compressed_file=compression()
print(compressed_file)
comp=compressed_file.split("static")
data['video_file'] = comp[1]
serializer = VideosSerialzers(data = data)
discription=data["video_discription"]
list_discription=discription.split(" ")
extract_list=[]
for list_item in list_discription:
start_with_hash=re.search("^#",list_item)
if start_with_hash:
extract_list.append(list_item)
else:
pass
for item in extract_list:
if Hastag.objects.filter(name__iexact=item).exists():
obj,created=Hastag.objects.get_or_create(count=1,user=request.user,name=item)
else:
obj,created=Hastag.objects.get_or_create(name=item,user=request.user)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def load(inputs_path, outputs_path):
"""
:param inputs_path: input file input dictionary format {file: operation}
:param outputs_path: The output file is transferred to the dictionary format {file: operation}
:return:
"""
f = FFmpeg(global_options=["-hide_banner", "-loglevel error"],
inputs={inputs_path: None},
outputs={
outputs_path: '-c copy',
})
print(f.cmd)
f.run()
return outputs_path
def CombineVideoAudio(self, video_list):
# num = 1
for item in video_list:
title1 = re.sub(r'[\/:*?"<>|]', '-', item['title'])
title = title1.replace(" ", "")
name1 = re.sub(r'[\/:*?"<>|]', '-', item['name'])
name = name1.replace("&", "and")
log_filename = "音视频合并看这里.txt"
log_filepath = r'D:\PythonDownload\bilibili\{dir_title}\{log_filename}'.format(
dir_title=title, log_filename=log_filename)
video_filename = name + '.mp4'
video_filepath = r'D:\PythonDownload\bilibili\{dir_title}\{video_filename}'.format(
dir_title=title,
video_filename=video_filename) # 设置图片name，注：必须加上扩展名
audio_filename = name + '.mp3'
audio_filepath = r'D:\PythonDownload\bilibili\{dir_title}\{audio_filename}'.format(
dir_title=title,
audio_filename=audio_filename) # 设置图片name，注：必须加上扩展名
out_filename = name + '-change.mp4'
out_filepath = r'D:\PythonDownload\bilibili\{dir_title}\{out_filename}'.format(
dir_title=title, out_filename=out_filename)
cmd = 'ffmpeg -i ' + video_filepath + ' -i ' + \
audio_filepath + ' -strict -2 -f mp4 ' + out_filepath
with open(log_filepath, 'a+') as f:
f.write(cmd + '\n')
f.write("\n")
f.close()
'''自动合并音视频'''
try:
print(f"--------{name} 音视频开始合并--------")
ff = FFmpeg(inputs={
video_filepath: None,
audio_filepath: None,
},
outputs={out_filepath: '-c:v h264 -c:a ac3'})
ff.run()
print(f"--------{name} 音视频合并完毕--------")
except Exception as err:
print("合并异常:" + str(err))
continue
with open(log_filepath, 'a+') as f:
f.write("\n")
f.write("------理论上会自动合并音视频，如有特殊情况合并失败可尝试以下手动方法。\n")
f.write(
"------电脑安装好FFmpeg配置好path环境变量后，复制以上命令到cmd命令窗口可以实现将音视频合并。\n")
f.write("------安装FFmpeg及配置path环境变量教程自行百度即可\n")
f.close()
print("--------log写入完毕--------")
def convertAudioFormat():
# c6md = "ffmpeg/bin/ffmpeg -i received_sound/received.mp4 -vn -ar 44100 -ac 2 -ab 192k -f mp3 new.wav"
# os.system(cmd)
print(os.getcwd())
# ff = FFmpeg(
ff = FFmpeg(
# executable='.\\ffmpeg\\bin\\ffmpeg.exe',
inputs={"received/sound/sound.mp4": None},
outputs={
"received/sound/" + "sound.wav":
'-vn -ar 16000 -ac 1 -ab 192k -f wav'
}
# outputs={"received_sound/" + "received.wav": '-vn -ar 44100 -ac 2 -ab 192k -f wav'}
)
ff.cmd
ff.run()
def recognize(request):
try:
audiofile = request.FILES.get('file', '')
answer = request.POST.get('answer', '')
change = os.path.join("Audio", audiofile.name)
if not os.path.exists("Audio"):
os.mkdir("Audio")
os.chmod(os.path.join("Audio", audiofile.name), 0o777)
with open(os.path.join(os.getcwd(), 'Audio', audiofile.name),
'wb') as fw:
os.chmod(os.path.join(os.getcwd(), "Audio", audiofile.name), 0o777)
for chunck in audiofile.chunks():
fw.write(chunck)
if (audiofile.name.split('.')[-1] != "wav"):
output = os.path.join(
"Audio", "".join(audiofile.name.split('.')[:-1]) + ".wav")
ff = FFmpeg(
inputs={change: None},
outputs={output: '-vn -ar 44100 -ac 2 -ab 192k -f wav'})
ff.cmd
ff.run()
else:
output = os.path.join("Audio", audiofile.name)
r = sr.Recognizer()
test = sr.AudioFile(output)
with test as source:
audio = r.record(source)
os.remove(output)
if (audiofile.name.split('.')[-1] != "wav"):
os.remove(change)
# language="cmn-Hans-CN"
result = r.recognize_google(audio, language="en-US", show_all=True)
judgeResult = judge(result['alternative'][0]['transcript'], answer)
return JsonResponse({
'state':
'success',
"result":
judgeResult,
"yourAnswer":
result['alternative'][0]['transcript'],
"trueAnswer":
answer
})
except Exception as e:
print(e)
return JsonResponse({'state': 'fail', "error": e.__str__()})
def decoder(video_path, bin_path, graph_num):
ff = FFmpeg(inputs={video_path: None}, outputs={'': '%d.png'})
print(ff.cmd)
ff.run()
for i in range(1, graph_num + 1):
image_dir = str(i) + ".png"
a = np.zeros((48, 8), dtype=np.uint8)
x = Image.open(image_dir).convert("L")
data = np.array(x)
for i in range(48):
for j in range(8):
a[i][j] = db.arr2byte(data[i * 20:(1 + i) * 20,
j * 160:(j + 1) * 160])
with open(bin_path, 'ab') as f:
f.write(a)
def mount_sub(video, srt):
"""
(deprecated 字幕直接串流到视频中)
:param video:
:param srt:
:return:
"""
extension = video.split('.')[-1]
output_video = video.replace(extension, 'mkv')
ff = FFmpeg(inputs={
video: None,
srt: None
},
global_options='-y',
outputs={output_video: None})
print(ff.cmd)
ff.run()
return output_video
def encoder(bin_path, out_path, time_lim, width=960, highth=960):
time_lim = int(time_lim)
fra = 10
pixel_size = 20
bin_in = dec2bin(bin_path)
x = len(bin_in)
row_num = int(highth / pixel_size) - 1
col_num = int(width / pixel_size / 8)
y = int(x // (row_num * col_num)) # 生成的图片数
if (y > time_lim * fra):
y = time_lim * fra
for i in range(y):
m = i * row_num * col_num
n = (i + 1) * row_num * col_num
bin_slice = bin_in[m:n]
list_CRC = for_CRC(bin_slice)
crc = CRC.CRC(list_CRC, 32)
#n=crc.code_list
#m=CRC.check(n)
#print(m)
c = form_CRC(crc)
img = np.zeros((highth + 12 * pixel_size, width + 12 * pixel_size),
dtype=np.uint8)
for j in range(row_num):
img[j * pixel_size + 120:(j + 1) * pixel_size + 120,
120:width + 120] = made_row(
bin_slice[j * col_num:(j + 1) * col_num], pixel_size,
width)
img[1060:1080, 120:1080] = c
img[100:1100, 100:120] = 255
img[100:1100, 1080:1100] = 255
img[1080:1100, 100:1100] = 255
img[100:120, 100:1100] = 255
im = Image.fromarray(img)
im.save(str(i) + ".png")
ff = FFmpeg(inputs={'': '-f image2 -r ' + str(fra) + ' -i %d.png'},
outputs={out_path: '-vcodec mpeg4'})
print(ff.cmd)
ff.run()
return y