video_editor/video_stitching/video_stitching.py

# -*- coding: utf-8 -*-
# @Time: 2023/12/26
import datetime
import random
import os
import sys
import time
import subprocess
import resource

import psutil
import requests
import urllib.parse


sys.path.append(os.getcwd())
from common import Feishu
from common.aliyun_oss_uploading import Oss
from common.common import Common
from common.db import MysqlHelper
from common.material import Material
from moviepy.editor import VideoFileClip, concatenate_videoclips
from moviepy import editor




output_path = "./video_stitching/video/new_video.mp4"
class VideoStitching():
    @classmethod
    def split_text(cls, text, max_length):
        words = text.split(' ')
        lines = []
        current_line = ''
        for word in words:
            if len(current_line) + len(word) <= max_length:
                current_line += word + ' '
            else:
                lines.append(current_line.strip())
                current_line = word + ' '
        lines.append(current_line.strip())
        result = ''.join(lines)
        result = result[:11] + '\n' + result[11:]  # 在第10个字后面增加换行
        return result

    @classmethod
    def srt_to_seconds(cls,srt_time):
        hours, minutes, seconds = map(float, srt_time.replace(',', '.').split(':'))
        return hours * 3600 + minutes * 60 + seconds

    @classmethod
    def insert_videoAudio(cls, audio_url, i):
        for j in audio_url:
            insert_sql = f"""INSERT INTO video_audio (audio, video_id, account_id, oss_object_key) values ("{i}", "{j[0]}", "{j[1]}", "{j[2]}")"""
            MysqlHelper.update_values(
                sql=insert_sql,
                env="prod",
                machine="",
            )

    # 随机生成id
    @classmethod
    def random_id(cls):
        now = datetime.datetime.now()
        rand_num = random.randint(10000, 99999)

        id = "{}{}".format(now.strftime("%Y%m%d%H%M%S"), rand_num)
        return id

    @classmethod
    def get_account_id(cls):
        account_id = f"""select account_id from video_url group by account_id;"""
        account_id = MysqlHelper.get_values(account_id, "prod")
        return account_id


    @classmethod
    def get_url_list(cls, audio_id, account):
        url_list = f"""SELECT a.video_id,a.account_id,a.oss_object_key FROM video_url a WHERE NOT EXISTS (
                SELECT video_id
                FROM video_audio b
                WHERE a.video_id = b.video_id AND b.audio = "{audio_id}"
            ) AND a.account_id = {account} ;"""
        url_list = MysqlHelper.get_values(url_list, "prod")
        return url_list

    # 新生成视频上传到对应账号下
    @classmethod
    def insert_piaoquantv(cls, oss_object_key):
        code = 1
        list = ["66481136", "66481137", "66481140", "66481141", "66481142"]
        for item in list:
            title = Material.get_title()
            url = "https://vlogapi.piaoquantv.com/longvideoapi/crawler/video/send"
            payload = dict(pageSource='vlog-pages/post/post-video-post', videoPath=oss_object_key, width='720',
                           height='1280', fileExtensions='mp4', viewStatus='1', title=title, careModelStatus='1',
                           token='f04f58d6e664cbc9902660a1e8d20ce6cd7fdb0f', loginUid=item, versionCode='719',
                           machineCode='weixin_openid_o0w175aZ4FJtqVsA1tcozJDJHdDU', appId='wx89e7eb06478361d7',
                           clientTimestamp='1703337579331',
                           machineInfo='{"sdkVersion":"3.2.5","brand":"iPhone","language":"zh_CN","model":"iPhone 12 Pro<iPhone13,3>","platform":"ios","system":"iOS 15.6.1","weChatVersion":"8.0.44","screenHeight":844,"screenWidth":390,"pixelRatio":3,"windowHeight":762,"windowWidth":390,"softVersion":"4.1.719"}',
                           sessionId='1703337560040-27bfe208-a389-f476-db1d-840681e04b32',
                           subSessionId='1703337569952-8f56d53c-b36d-760e-8abe-0b4a027cd5bd', senceType='1089',
                           hotSenceType='1089', id='1050', channel='pq')

            payload['videoPath'] = oss_object_key
            payload['title'] = title

            data = urllib.parse.urlencode(payload)

            headers = {
                'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 15_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.44(0x18002c2d) NetType/WIFI Language/zh_CN',
                'Accept-Encoding': 'gzip,compress,br,deflate',
                'Referer': 'https://servicewechat.com/wx89e7eb06478361d7/726/page-frame.html',
                'Content-Type': 'application/x-www-form-urlencoded',
                'Cookie': 'JSESSIONID=A60D96E7A300A25EA05425B069C8B459'
            }

            response = requests.post(url, data=data, headers=headers)
            data = response.json()
            code = data["code"]
        if code == 0:
            return True
        else:
            return False

    def get_io_bps(cls):
        io_counters = psutil.Process().io_counters()
        read_bps = io_counters.read_bytes / 5  # 每秒读取的字节数
        write_bps = io_counters.write_bytes / 5  # 每秒写入的字节数
        Common.logger().info(f"当前读取速度：{read_bps} B/s")
        Common.logger().info(f"当前写入速度：{write_bps} B/s")


    # 视频拼接
    @classmethod
    def concatenate_videos(cls, videos, audio, srt):
        clips = []
        total_duration = 0
        included_videos = []
        # 设置最大可使用的内存限制（单位：字节）
        memory_limit = 6 * 1024 * 1024 * 1024  # 6GB
        resource.setrlimit(resource.RLIMIT_AS, (memory_limit, memory_limit))
        # 提取视频的音频
        Common.logger().info(f"开始提取视频的音频{audio}")
        video1 = VideoFileClip(audio)
        mp3 = video1.audio
        Common.logger().info(f"提取视频的音频成功")

        # 获取音频时长（以秒为单位）
        duration_limit = mp3.duration

        # 遍历每个视频并计算总时长
        for i, video in enumerate(videos):
            clip = VideoFileClip(video[3])
            clips.append(clip)
            total_duration += clip.duration
            if total_duration >= duration_limit:
                break

        # 如果总时长小于等于目标时长，则不做视频拼接
        if total_duration <= duration_limit:
            Common.logger().info(f"时长小于等于目标时长，不做视频拼接")
            return ""
        else:
            Common.logger().info(f"总时长大于目标时长")
            remaining_time = duration_limit
            final_clips = []

            for clip, video in zip(clips, videos):
                if remaining_time - clip.duration >= 0:
                    final_clips.append(clip)
                    included_videos.append(video)
                    remaining_time -= clip.duration
                else:
                    # 如果剩余时间不足以加入下一个视频，则截断当前视频并返回已包含的URL
                    final_clips.append(clip.subclip(0, remaining_time))
                    included_videos.append(video)
                    break
            final_clip = concatenate_videoclips(final_clips)
        final_clip = final_clip.set_audio(mp3)
        # 统一设置视频分辨率
        final_width = 480
        final_height = 720
        final_clip = final_clip.resize((final_width, final_height))
        # 设置背景色
        color_clip = editor.ColorClip(size=(final_width, 120),
                                      color=(255, 255, 0)).set_duration(duration_limit)
        final_clip = editor.CompositeVideoClip([final_clip, color_clip.set_position(("center", final_height - 100))])
        # 处理SRT字幕文件
        subtitle_file = f"./video_stitching/video/{srt}.srt"
        Common.logger().info(f"处理SRT字幕文件")
        if os.path.isfile(subtitle_file):
            with open(subtitle_file, 'r') as file:
                cls.get_io_bps()
                subtitles = file.read().strip().split('\n\n')
            # 从SRT字幕文件中获取字幕
            subtitle_clips = []
            for subtitle in subtitles:
                # 按行分割字幕内容
                subtitle_lines = subtitle.strip().split('\n')
                # 提取时间轴信息和字幕文本
                if len(subtitle_lines) >= 3:
                    times, text = subtitle_lines[1], '\n'.join(subtitle_lines[2:])
                    start, end = map(cls.srt_to_seconds, times.split(' --> '))
                    start = editor.cvsecs(start)
                    end = editor.cvsecs(end)
                text = cls.split_text(text, 10)
                # /System/Library/Fonts/Hiragino Sans GB.ttc 本地字体
                Common.logger().info(f"字幕:{text}")

                sub = editor.TextClip(text, font="/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc",
                                      fontsize=30, color="black").set_duration(end - start).set_start(
                    start).set_position(
                    ("center", final_height - 80)).set_opacity(0.8)
                subtitle_clips.append(sub)
            Common.logger().info(f"将字幕添加到视频上")
            # 将字幕添加到视频上
            video_with_subtitles = editor.CompositeVideoClip([final_clip] + subtitle_clips)
        else:
            text_clip = (
                editor.TextClip("分享、转发给群友", font="/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc",
                                fontsize=30, color="black").
                    set_position(("center", final_height - 80)).
                    set_duration(duration_limit).
                    set_opacity(0.8)
            )
            # 把 `文本剪贴板` 贴在视频上
            video_with_subtitles = editor.CompositeVideoClip([final_clip, text_clip])

        # 生成视频
        cls.get_io_bps()
        video_with_subtitles.write_videofile(output_path, codec='libx264', fps=24)
        if os.path.isfile(output_path):
            Common.logger().info("视频生成成功！生成路径为:", output_path)
            return included_videos, video_with_subtitles
        else:
            Common.logger().info("视频生成失败，请检查代码和文件路径。")
            return "", video_with_subtitles


    @classmethod
    def get_audio_url(cls, i, cookie):
        url = f"https://admin.piaoquantv.com/manager/video/detail/{i}"

        payload = {}
        headers = {
            'authority': 'admin.piaoquantv.com',
            'accept': 'application/json, text/plain, */*',
            'accept-language': 'zh-CN,zh;q=0.9',
            'cache-control': 'no-cache',
            'cookie': cookie,
            'pragma': 'no-cache',
            'referer': f'https://admin.piaoquantv.com/cms/post-detail/{i}/detail',
            'sec-ch-ua': '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
            'sec-ch-ua-mobile': '?0',
            'sec-ch-ua-platform': '"macOS"',
            'sec-fetch-dest': 'empty',
            'sec-fetch-mode': 'cors',
            'sec-fetch-site': 'same-origin',
            'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
        }

        response = requests.request("GET", url, headers=headers, data=payload)
        data = response.json()
        try:
            code = data["code"]
            if code != 0:
                Common.logger().info(
                    f"未登录，请更换cookie，{data}")
                Feishu.bot('recommend', '管理后台', '管理后台cookie失效，请及时更换～')
                # 如果返回空信息，则随机睡眠 600, 1200 秒
                time.sleep(random.randint(600, 1200))
                cls.video_cookie()

            audio_url = data["content"]["transedVideoPath"]
            print(audio_url)
            return audio_url
        except Exception as e:
            Common.logger().warning(f"获取音频视频链接失败:{e}\n")
            return ""

    @classmethod
    def video_stitching(cls, cookie):
        count = 0
        while True:
            # 获取音频
            audioid = Material.get_audio()
            # 获取已入库的用户id
            account_id = cls.get_account_id()
            audio_id = random.choice(audioid)
            account = random.choice(account_id)
            account = str(account).replace('(', '').replace(')', '').replace(',', '')
            Common.logger().info(f"获取用户ID：{account}")
            # 获取 未使用的视频链接
            url_list = cls.get_url_list(audio_id, account)
            # 获取音频url
            audio = cls.get_audio_url(audio_id, cookie)
            if audio == "":
                continue
            Common.logger().info(f"获取音频地址：{audio},获取用户id：{audio_id}")
            videos = [list(item) for item in url_list]
            videos = Oss.get_oss_url(videos)
            # 视频截取
            try:
                audio_url, video_with_subtitles = cls.concatenate_videos(videos, str(audio), audio_id)
                if len(audio_url) == 0:
                    Common.logger().info(f"视频生成失败")
                    continue
                # 随机生成视频id
                id = cls.random_id()
                Common.logger().info(f"生成视频id为：{id}")
                # 上传 oss
                oss_object_key = Oss.stitching_sync_upload_oss(output_path, id)
                status = oss_object_key.get("status")
                # 获取 oss 视频地址
                oss_object_key = oss_object_key.get("oss_object_key")
                Common.logger().info(f"新拼接视频，oss发送成功，oss地址：{oss_object_key}")
                if status == 200:
                    time.sleep(10)
                    # 发送成功 已使用视频存入数据库
                    cls.insert_videoAudio(audio_url, audio)
                    Common.logger().info(f"发送成功 已使用视频存入数据库完成")
                    if os.path.isfile(output_path):
                        os.remove(output_path)
                        Common.logger().info(f"文件删除成功{output_path}")
                    else:
                        Common.logger().info(f"文件不存在{output_path}")
                    piaoquantv = cls.insert_piaoquantv(oss_object_key)
                    if piaoquantv:
                        time.sleep(120)
                        count += 1
                        Common.logger().info(f"视频添加到对应用户成功")

                        if count >= 5:
                            break
                        # 释放视频对象
                        video_with_subtitles.close()
            except Exception as e:
                Common.logger().warning(f"新拼接视频发送oss失败:{e}\n")
                continue
            if count >= 5:
                break

    @classmethod
    def video_cookie(cls):
        # 获取后台cookie
        cookie = Material.get_houtai_cookie()
        cls.video_stitching(cookie)





if __name__ == '__main__':
    VideoStitching.video_stitching()