# -*- coding: utf-8 -*-

from random import *
from string import *
from time import *
from math import *
import math
import codecs
import ImageFont, ImageDraw, Image

#时间字符变时间长度
def str2time(strt='0:00:00.00'):
    tt = strt.split(':')
    return (int(tt[0])*60+int(tt[1]))*60*100+int((tt[2]).split('.')[0])*100+int((tt[2]).split('.')[1])

#时间长度变字符时间
def time2str(timet=0):
    t1 = int(timet/100/60/60)
    t2 = int((timet-t1*100*60*60)/100/60)
    t3 = int(timet-t1*100*60*60-t2*100*60)
    t1s = str(t1)
    t2s = str(t2)
    if len(t2s) == 1 : t2s = '0'+t2s
    t3s = str(t3)
    if len(t3s) == 1 : t3s = '000'+ t3s
    if len(t3s) == 2 : t3s = '00'+ t3s
    if len(t3s) == 3 : t3s = '0'+ t3s
    return t1s+':'+t2s+':'+t3s[0:2]+'.'+t3s[2:4]

#字体设置
def font_set(font_enc=1, font_add='', font_size=1, font_sb=0, font_pix=0):
    if font_enc == 1 : encode = 'unic'
    elif font_enc == 2 : encode = 'symb'
    elif font_enc == 3 : encode = 'ADOB'
    elif font_enc == 4 : encode = 'ADBE'
    elif font_enc == 5 : encode = 'armn'
    else : encode = 'unic'
    
    font1 = ImageFont.truetype(font_add, font_size+font_sb, encoding=encode)
    font2 = ImageFont.truetype(font_add, font_size+font_pix, encoding=encode)
    return (font1,font2)

#左切割字符
def ltrim(string = '',lon = 0) :
    lstr = ''
    i=0
    while i < lon :
        lstr = lstr + string[i]
        i=i+1
    return lstr


#右切割字符
def rtrim(string = '',lon = 0) :
    total = len(string)
    rstr = ''
    i=0
    while i < total :
        if not i+lon < total : rstr = rstr + string[i]
        i=i+1
    return rstr

#拆分字符串
def txt_cai(txt_div, time_div, txt, font, size) :
    
    atime = []
    atext = []
    akuan = []

    for ll in txt :
        #ll=ll.decode("utf-8")
        txt2 = ll.split(',',9)
        time_sta = str2time(txt2[1])
        time_end = str2time(txt2[2])
        txt_ee = txt2[9].split('{\\') #切割
        i=1
        a1=[]
        a2=[]
        a3=[]
        while i < len(txt_ee) :
            txt_e2 = txt_ee[i].split('}',1)
            if txt_div and len(txt_e2[1].decode("utf-8"))>1 :
                lmax = len(txt_e2[1].decode("utf-8"))
                timm = int(rtrim(txt_e2[0],len(txt_e2[0])-1))
                sn = 0
                while sn < lmax :
                    if time_div :
                        a1.append(time2str(time_sta+timm*sn/lmax)+','+time2str(time_sta+timm*(sn+1)/lmax))
                    else :
                        a1.append(time2str(time_sta)+','+time2str(time_sta+timm))
                    a2.append(txt_e2[1].decode("utf-8")[sn].encode('utf-8'))
                    a3.append(font.getsize(txt_e2[1].decode("utf-8")[sn])[0]+size)
                    sn = sn+1
            else :
                a1.append(time2str(time_sta)+','+time2str(time_sta+int(rtrim(txt_e2[0],len(txt_e2[0])-1))))
                a2.append(txt_e2[1])#.decode("utf-8"))
                a3.append(font.getsize(txt_e2[1].decode("utf-8"))[0]+size)
            time_sta=time_sta+int(rtrim(txt_e2[0],len(txt_e2[0])-1))
            i=i+1
        atime.append(a1)
        atext.append(a2)
        akuan.append(a3)

    txt_end = (atime,atext,akuan,font.getsize(txt_e2[1].decode("utf-8"))[1]+size)
    return txt_end

#中文翻译拆分
def txt_caicn(txt_div, time_div, txt, font, size) :
    
    atime = []
    atext = []
    akuan = []

    for ll in txt :
        #ll=ll.decode("utf-8")
        txt2 = ll.split(',',9)
        time_sta = str2time(txt2[1])
        time_end = str2time(txt2[2])
        time_total = time_end - time_sta
        txt_ee = txt2[9]
        a1=[]
        a2=[]
        a3=[]
        if txt_div :
            i=0
            while i < len(txt_ee.decode("utf-8")) :
                if time_div :
                    a1.append(time2str(time_sta+time_total*i/len(txt_ee.decode("utf-8")))+','+time2str(time_sta+time_total*(i+1)/len(txt_ee.decode("utf-8"))))
                else :
                    a1.append(time2str(time_sta)+','+time2str(time_end))
                a2.append(txt_ee.decode("utf-8")[i].encode('utf-8'))
                a3.append(font.getsize(txt_ee.decode("utf-8")[i])[0]+size)
                i=i+1
        else :
            a1.append(time2str(time_sta)+','+time2str(time_end))
            a2.append(txt_ee)
            a3.append(font.getsize(txt_ee.decode("utf-8"))[0]+size)
        
        atime.append(a1)
        atext.append(a2)
        akuan.append(a3)

    txt_end = (atime,atext,akuan,font.getsize(txt_ee.decode("utf-8"))[1]+size)
    return txt_end


#单字粒子拆分
def fontpix(string, fnt, kz =0):
    string = ' ' + string + ' '
    size = fnt.getsize(string.decode("utf-8"))
    ksize = fnt.getsize(' '.decode("utf-8"))[0]
    img=Image.new('RGB',size,'white')
    drimg=ImageDraw.Draw(img)
    drimg.text((0,0),string.decode("utf-8"),font=fnt,fill='black')
    del drimg
    

    if kz == 0 :
        x=0
        y=0
        return_im=[]
        while x<size[0]:
            y=0
            while y<size[1]:
                box = x,y,x+1,y+1
                nim = img.crop(box)
                aa = nim.getcolors()
                if aa[0][1][0]!=255 and aa[0][1][1]!=255 and aa[0][1][2]!=255 :
                    alpha = upper(hex(aa[0][1][0]))[2:5]
                    if len(alpha)==1:
                        alpha='0'+alpha
                    return_im.append([x-ksize,y,alpha])
                y=y+1
            x=x+1
    else :
        x=0
        y=0
        return_im=[]
        while y<size[1]:
            x=0
            while x<size[0]:
                box = x,y,x+1,y+1
                nim = img.crop(box)
                aa = nim.getcolors()
                if aa[0][1][0]!=255 and aa[0][1][1]!=255 and aa[0][1][2]!=255 :
                    alpha = upper(hex(aa[0][1][0]))[2:5]
                    if len(alpha)==1:
                        alpha='0'+alpha
                    return_im.append([x-ksize,y,alpha])
                x=x+1
            y=y+1        
    return return_im

#产生头信息
def create_tit(TIT_SCR_KAR='', COL_FIN_SCR=0, LIN_FIN_SCR=0):
    lists = []
    ss=''
    ss=ss+'[Script Info]\n\n\n'
    ss=ss+'Title:'+TIT_SCR_KAR+'\n'
    ss=ss+'Original Script:\n'
    ss=ss+'Synch Point:0\nScriptType:v4.00+\nCollisions:Normal\n'
    ss=ss+'PlayResX:'+str(COL_FIN_SCR)+'\n'
    ss=ss+'PlayResY:'+str(LIN_FIN_SCR)+'\n'
    ss=ss+'Timer:100.0000\n\n[V4+ Styles]\n'
    lists.append(ss)
    return lists


#颜色分割
def cut_color(no, str_color, end_color):
    scr=int(str_color[0:2],16)
    scg=int(str_color[2:4],16)
    scb=int(str_color[4:6],16)
    enr=int(end_color[0:2],16)
    eng=int(end_color[2:4],16)
    enb=int(end_color[4:6],16)
    return_color=[]
    no_t=0
    while no_t<no :
        r_return=upper(hex(scr+no_t*(enr-scr)/(no-1))[2:5])
        g_return=upper(hex(scg+no_t*(eng-scg)/(no-1))[2:5])
        b_return=upper(hex(scb+no_t*(enb-scb)/(no-1))[2:5])
        if len(r_return)==1:
            r_return='0'+r_return
        if len(g_return)==1:
            g_return='0'+g_return
        if len(b_return)==1:
            b_return='0'+b_return
        return_color.append(r_return+g_return+b_return)
        no_t=no_t+1
    return return_color


#产生随机图形
def tu_sui(shu=4, kuan=10, gao=10):
    tutu='m '
    x1 = randint(0,kuan)
    y1 = randint(0,gao)
    tutu = tutu+str(x1)+' '+str(y1)+' b '
    ss=0
    while ss < shu :
        bb = 0
        while bb < 3 :
            x1 = randint(0,kuan)
            y1 = randint(0,gao)
            tutu = tutu+str(x1)+' '+str(y1)+' '
            bb = bb + 1
        ss = ss+1
    tutu = tutu + 'c'
    return tutu


#图形偏移
def tu_pian(tu,no_x,no_y):
    ll=tu.split(' ')
    x=0
    hs=1
    while x<len(ll) :
        if not ll[x] in ['m','n','c','p','b','l','s'] :
            if hs == 1 :
                ll[x]=str(int(ll[x])+no_x)
                hs = -1
            else :
                ll[x]=str(int(ll[x])+no_y)
                hs = 1
        x=x+1
    tu=' '.join(ll)
    return tu


#按照x轴对换
def tu_change_x(tu):
    ll=tu.split(' ')
    x=0
    hs=1
    while x<len(ll) :
        if not ll[x] in ['m','n','c','p','b','l','s'] :
            if hs == 1 :
                ll[x]=str(-int(ll[x]))
                hs = -1
            else :
                ll[x]=str(int(ll[x]))
                hs = 1
        x=x+1
    tu=' '.join(ll)
    return tu


#按照y轴对换
def tu_change_y(tu):
    ll=tu.split(' ')
    x=0
    hs=-1
    while x<len(ll) :
        if not ll[x] in ['m','n','c','p','b','l','s'] :
            if hs == 1 :
                ll[x]=str(-int(ll[x]))
                hs = -1
            else :
                ll[x]=str(int(ll[x]))
                hs = 1
        x=x+1
    tu=' '.join(ll)
    return tu


#分割黑色图片到点
def clip_image(image_path,kuan,gao):
    import Image
    im = Image.open(image_path)
    x=0
    y=0
    return_im=[]
    while y<gao:
        x=0
        while x<kuan:
            box = x,y,x+1,y+1
            nim = im.crop(box)
            aa = nim.getcolors()
            if aa[0][1][0]!=255 and aa[0][1][1]!=255 and aa[0][1][2]!=255 :
                return_im.append([x,y,aa[0][1][0]])
            x=x+1
        y=y+1
    return return_im


#拼接扫描后的点
def tu_x(clip_im,alpha):
    return_tu=''
    xx=0
    while xx<len(clip_im) :
        if alpha == clip_im[xx][3] and alpha == 0 :
            return_tu=return_tu+'m '+str(clip_im[xx][0])+' '+str(clip_im[xx][1])+' l '+str(clip_im[xx][0])+' '+str(clip_im[xx][1]+1)+' '+str(clip_im[xx][0]+1)+' '+str(clip_im[xx][1]+1)+' '+str(clip_im[xx][0]+1)+' '+str(clip_im[xx][1])+' c '
        elif alpha != 0 :
            return_tu=return_tu+'m '+str(clip_im[xx][0])+' '+str(clip_im[xx][1])+' l '+str(clip_im[xx][0])+' '+str(clip_im[xx][1]+1)+' '+str(clip_im[xx][0]+1)+' '+str(clip_im[xx][1]+1)+' '+str(clip_im[xx][0]+1)+' '+str(clip_im[xx][1])+' c '
        xx=xx+1
    return_tu=strip(return_tu)
    return return_tu


###########################贝塞尔曲线##############################

def xn(shu,fang) :
    x=0
    y=1.0
    while x<fang:
       y=y*shu
       x=x+1
    return y

def cn(xx,xs) :
    x1 = 1
    x = 0
    while x< xs :
        x1 = x1*xx
        xx=xx-1
        x=x+1
    x2 = 1
    while xs>0 :
        x2=x2*xs
        xs=xs-1
    xz = 0.0
    xz = x1/x2
    return xz


def bezl(x0=0, y0=0, x1=1, y1=1, lis=[], mi=4, fs=0) :
    num = len(lis)+1
    if mi <= 0 : mi=1
    xz=0.0
    yz=0.0
    x=0
    t=0
    cd =0
    xl = [x0]
    yl = [y0]
    while cd < num-1 :
        xl.append(lis[cd][0])
        yl.append(lis[cd][1])
        cd=cd+1
    xl.append(x1)
    yl.append(y1)
    tshu = max(max(xl)-min(xl),max(yl)-min(xl))*1.0*mi
    if tshu == 0 :
        tshu = 1
    rev =[]
    while t<=1 :
        xz=0.0
        yz=0.0
        x=0
        while x<=num:
            xz=xz+cn(num,x)*xn(1-t,num-x)*xn(t,x)*xl[x]
            yz=yz+cn(num,x)*xn(1-t,num-x)*xn(t,x)*yl[x]
            x=x+1
        if fs == 1 :
            xz = int(xz)
            yz = int(yz)
        if fs == 2 :
            xz = round(xz,0)
            yz = round(yz,0)
        if fs == 3 :
            xz = round(xz,2)
            yz = round(yz,2)
        if len(rev)==0 :
            rev.append([xz,yz])
        else :
            if not ([xz,yz] == rev[len(rev)-1]) :
                rev.append([xz,yz])
        t = (t*1000000 + 1000000/tshu)/1000000
    return(rev)


def bezl2(lis=[], mi=4, fs=0) :
    num = len(lis)-1
    if mi <= 0 : mi=1
    xz=0.0
    yz=0.0
    x=0
    t=0
    cd =0
    xl=[]
    yl=[]
    while cd < num+1 :
        xl.append(lis[cd][0])
        yl.append(lis[cd][1])
        cd=cd+1
    tshu = max(max(xl)-min(xl),max(yl)-min(xl))*1.0*mi
    rev =[]
    while t<=1 :
        xz=0.0
        yz=0.0
        x=0
        while x<=num:
            xz=xz+cn(num,x)*xn(1-t,num-x)*xn(t,x)*xl[x]
            yz=yz+cn(num,x)*xn(1-t,num-x)*xn(t,x)*yl[x]
            x=x+1
        if fs == 1 :
            xz = int(xz)
            yz = int(yz)
        if fs == 2 :
            xz = round(xz,0)
            yz = round(yz,0)
        if fs == 3 :
            xz = round(xz,2)
            yz = round(yz,2)
        if len(rev)==0 :
            rev.append([xz,yz])
        else :
            if not ([xz,yz] == rev[len(rev)-1]) :
                rev.append([xz,yz])
        t = (t*1000000 + 1000000/tshu)/1000000
    return(rev)



def bez1(x0=0, y0=0, x1=1, y1=1, mi=4, fs=0) :
    rev = bezl(x0, y0, x1, y1, [], mi, fs)
    return(rev)


def bez2(x0=0, y0=0, x1=1, y1=1, x2=2, y2=3, mi=4, fs=0) :
    rev = bezl(x0, y0, x1, y1, [[x2,y2]], mi, fs)
    return(rev)


def bez3(x0=0, y0=0, x1=1, y1=1, x2=2, y2=3, x3=3, y3=2, mi=4, fs=0) :
    rev = bezl(x0, y0, x3, y3, [[x1,y1],[x2,y2]], mi, fs)
    return(rev)

def tu2lis(tus='',mi=4,fs=0,bh=0) :
    kz = ''
    main_list = tus.split(' ')
    rlis = []
    i = 0
    while i < len(main_list) :
        if main_list[i] in ['m','n','l','b','s','c'] :
            kz = ''
        if main_list[i] == 'm' :
            if bh == 1 and (kz == 'l' or kz == 'b') :
                lis = bezl(x_q, y_q, x_first, y_first, [], mi, fs)
                rlis = rlis+lis                  
            x_first = int(main_list[i+1])
            y_first = int(main_list[i+2])
            x_q = int(main_list[i+1])
            y_q = int(main_list[i+2])
            i=i+3
        if main_list[i] == 'l' or kz == 'l' :
            if kz == 'l' : i = i-1
            kz = 'l'
            x_l = int(main_list[i+1])
            y_l = int(main_list[i+2])
            
            lis = bezl(x_q, y_q, x_l, y_l, [], mi, fs)
            rlis = rlis+lis
            
            x_q = x_l
            y_q = y_l
            i=i+3
        if main_list[i] == 'b' or kz == 'b' :
            if kz == 'b' : i = i-1
            kz = 'b'
            x_b_1 = int(main_list[i+1])
            y_b_1 = int(main_list[i+2])
            x_b_2 = int(main_list[i+3])
            y_b_2 = int(main_list[i+4])           
            x_b_3 = int(main_list[i+5])
            y_b_3 = int(main_list[i+6])
            
            lis = bezl(x_q, y_q, x_b_3, y_b_3, [[x_b_1,y_b_1],[x_b_2,y_b_2]], mi, fs)
            rlis = rlis+lis

            x_q = x_b_3
            y_q = y_b_3
            i = i+7
        if i<len(main_list) :
            if main_list[i] == 'c' :
                kz = 'c'
                lis = bezl(x_q, y_q, x_first, y_first, [], mi, fs)
                rlis = rlis+lis
                i = i+1
        if bh == 1 and i>=len(main_list) and (kz == 'l' or kz == 'b') :
            lis = bezl(x_q, y_q, x_first, y_first, [], mi, fs)
            rlis = rlis+lis            
    return rlis


########################################################################


def tx1(stas=0, jg=5, num=1, tl=['t1','t2']) :
    '''tx1(开始时间, 时间间隔, 数量, 特效list)'''
    stas = int(stas*10)
    jg = int(jg*10)
    tnum = len(tl)
    tos = ''
    x=0
    while x<num :
        tos = tos + t1(stas,stas+jg,tl[x%tnum])
        stas = stas + jg
        x=x+1
    return tos


def tx2(stas=0, timel=0, num=1, tl=['t1','t2']) :
    '''tx2(开始时间, 时间长度, 数量, 特效list)'''
    stas = int(stas*10)
    timel = int(timel*10)
    tnum = len(tl)
    tos = ''
    x=0
    while x<num :
        tos = tos + t1(stas+x*timel/num,stas+(x+1)*timel/num,tl[x%tnum])
        x=x+1
    return tos

def tx3(stas=0, mint=0, maxt=5, num=1, tl=['t1','t2']) :
    '''tx3(开始时间, 时间长度最小值, 时间长度最大值, 数量, 特效list)'''
    stas = int(stas*10)
    mint2 = int(min(mint,maxt)*10)
    maxt2 = int(max(mint,maxt)*10)
    jg = randint(mint2,maxt2)
    tnum = len(tl)
    tos = ''
    x=0
    while x<num :
        tos = tos + t1(stas,stas+jg,tl[x%tnum])
        stas = stas + jg
        x=x+1
    return tos

def cir(radii=10, angle=0, fs=0) :
    '''cir(半径, 角度, 方式)'''
    if fs == 0 :
        tox = int(round(radii*math.cos(3.1415926*angle/180),0))
        toy = int(round(radii*math.sin(3.1415926*angle/180),0))
    if fs == 1 :
        tox = round(radii*math.cos(3.1415926*angle/180),2)
        toy = round(radii*math.sin(3.1415926*angle/180),2)
    return [tox,toy]


def numok() :
    '''返回1或-1'''
    x=randint(0,1)
    if x == 0 : x = -1
    return x

def numsui(num1=0,num2=0) :
    '''随机返回两个值的中间值'''
    num1 = int(num1)
    num2 = int(num2)
    minn = min(num1,num2)
    maxn = max(num1,num2)
    return(randint(minn,maxn))

def listsui(listl=[]) :
    '''随机返回list中的一个值'''
    num = len(listl)
    return(listl[randint(0,num-1)])






#对齐调整
def an_check(CON_LIN_KAR, LIS_FRA_LEF, LIS_FRA_LMI, LIS_FRA_MID, LIS_FRA_RMI, LIS_FRA_RIG, ALI_FRA_KAR) :
    '''对齐调整...运行到行数,左对齐,左中对齐,中对齐,右中对齐,右对齐'''
    if CON_LIN_KAR in LIS_FRA_LEF :
        return 1
    elif CON_LIN_KAR in LIS_FRA_LMI :
        return 4
    elif CON_LIN_KAR in LIS_FRA_MID :
        return 2
    elif CON_LIN_KAR in LIS_FRA_RMI :
        return 5
    elif CON_LIN_KAR in LIS_FRA_RIG :
        return 3
    else :
        return ALI_FRA_KAR



#测试
def css(ss) :
    '''测试'''
    global aa
    aa = ss

###########################全局控制##################################

def maskz(mass):
    '''mas控制'''
    global GER_SSA_MAS
    GER_SSA_MAS = mass

mas_l = []

####################################################################

###########################239中的一些##############################

def xbord(_bord_=1):
    return '\\xbord'+str(_bord_)

def ybord(_bord_=1):
    return '\\ybord'+str(_bord_)

def xshad(_shad_=1):
    return '\\xshad'+str(_shad_)

def yshad(_shad_=1):
    return '\\yshad'+str(_shad_)

def fax(_fax_=1):
    return '\\fax'+str(_fax_)

def fay(_fay_=1):
    return '\\fay'+str(_fay_)

def be239(_be_=1):
    if _be_ < 0 : _be_ = 0
    if GER_SSA_MAS :
        mas_l.append('\\be'+str(_be_))        
        return '[mas_sta]'+str(len(mas_l)-1)+'[mas_end]'
    else :
        return '\\be'+str(_be_)

def blur(_blur_=1):
    if _blur_ < 0 : _blur_ = 0
    if _blur_ > 100 : _blur_ = 100
    return '\\blur'+str(_blur_)

def pos239(_pos_x_=0,_pos_y_=0):
    _pos_x_ = float(int(_pos_x_*100))/100
    _pos_y_ = float(int(_pos_y_*100))/100
    if _pos_x_%1 == 0 : _pos_x_ = int(_pos_x_)
    if _pos_y_%1 == 0 : _pos_y_ = int(_pos_y_)
    return '\\pos('+str(_pos_x_)+','+str(_pos_y_)+')'

def move239(_sta_pos_x_=0,_sta_pos_y_=0,_end_pos_x_=0,_end_pos_y_=0,_sta_time_=0,_end_time_=0):
    _sta_pos_x_ = float(int(_sta_pos_x_*100))/100
    _sta_pos_y_ = float(int(_sta_pos_y_*100))/100
    _end_pos_x_ = float(int(_end_pos_x_*100))/100
    _end_pos_y_ = float(int(_end_pos_y_*100))/100
    _sta_time_ = int(_sta_time_)
    _end_time_ = int(_end_time_)
    if _sta_pos_x_%1 == 0 : _sta_pos_x_ = int(_sta_pos_x_)
    if _sta_pos_y_%1 == 0 : _sta_pos_y_ = int(_sta_pos_y_)
    if _end_pos_x_%1 == 0 : _end_pos_x_ = int(_end_pos_x_)
    if _end_pos_y_%1 == 0 : _end_pos_y_ = int(_end_pos_y_)
    if (_sta_time_ == 0 and _end_time_ == 0) or _end_time_ < _sta_time_ :
        return '\\move('+str(_sta_pos_x_)+','+str(_sta_pos_y_)+','+str(_end_pos_x_)+','+str(_end_pos_y_)+')'
    else :
        return '\\move('+str(_sta_pos_x_)+','+str(_sta_pos_y_)+','+str(_end_pos_x_)+','+str(_end_pos_y_)+','+str(_sta_time_)+','+str(_end_time_)+')'

def t1(_sta_time_=0,_end_time_=0,_eff_='') :
    _sta_time_ = float(int(_sta_time_*100))/100
    _end_time_ = float(int(_end_time_*100))/100
    if _sta_time_%1 == 0 : _sta_time_ = int(_sta_time_)
    if _end_time_%1 == 0 : _end_time_ = int(_end_time_)
    if _end_time_ < _sta_time_ : _end_time_ = _sta_time_
    return '\\t('+str(_sta_time_)+','+str(_end_time_)+','+_eff_+')'

def t2(_sta_time_=0,_end_time_=0,_aa_=1,_eff_='') :
    _sta_time_ = float(int(_sta_time_*100))/100
    _end_time_ = float(int(_end_time_*100))/100
    _aa_ = float(int(_aa_*100))/100
    if _sta_time_%1 == 0 : _sta_time_ = int(_sta_time_)
    if _end_time_%1 == 0 : _end_time_ = int(_end_time_)
    if _aa_%1 == 0 : _aa_ = int(_aa_)
    if _end_time_ < _sta_time_ : _end_time_ = _sta_time_
    return '\\t('+str(_sta_time_)+','+str(_end_time_)+','+str(_aa_)+','+_eff_+')'
 
def clip1(_size_=1,_tu_='') :
    _size_ = int(_size_)
    return '\\clip('+str(_size_)+','+_tu_+')'

def iclip(_sta_x_=0,_sta_y_=0,_end_x_=0,_end_y_=0) :
    _sta_x_ = int(_sta_x_)
    _sta_y_ = int(_sta_y_)
    _end_x_ = int(_end_x_)
    _end_y_ = int(_end_y_)
    return '\\iclip('+str(_sta_x_)+','+str(_sta_y_)+','+str(_end_x_)+','+str(_end_y_)+')'

def iclip1(_size_=1,_tu_='') :
    _size_ = int(_size_)
    return '\\iclip('+str(_size_)+','+_tu_+')'

####################################################################

###########################基本代码##################################

def b(bol=0):
    '''生成特效代码 \\b值'''
    if not bol == 0 :
        bol = 1
    return '\\b'+str(bol)

def i(ite = 0):
    '''生成特效代码 \\i值'''
    if not ite == 0 :
        ite = 1
    return '\\i'+str(ite)

def u(dow = 0):
    '''生成特效代码 \\u值'''
    if not dow == 0 :
        dow = 1
    return '\\u'+str(dow)

def s(dow = 0):
    '''生成特效代码 \\s值'''
    if not dow == 0 :
        dow = 1
    return '\\s'+str(dow)

def be(_be_=1):
    '''生成特效代码 \\be值'''
    if _be_ < 0 : _be_ = 0
    if GER_SSA_MAS :
        mas_l.append('\\be'+str(_be_))        
        return '[mas_sta]'+str(len(mas_l)-1)+'[mas_end]'
    else :
        return '\\be'+str(_be_)
    
def bord(bor = 0):
    '''生成特效代码 \\bord值'''
    if bor < 0 : bor = 0
    bor = float(int(bor*100))/100
    if bor%1 == 0 : bor = int(bor)
    return '\\bord'+str(bor)

def shad(sha = 0):
    '''生成特效代码 \\shad值'''
    if sha < 0 : sha = 0
    sha = float(int(sha*100))/100
    if sha%1 == 0 : sha = int(sha)
    return '\\shad'+str(sha)

def fn(nam= 'Arial'):
    '''生成特效代码 \\fn名字'''
    return '\\fn'+str(nam)

def fs(siz=0):
    '''生成特效代码 \\fs值'''
    siz = int(siz)
    return '\\fs'+str(siz)

def fscx(scx=0):
    '''生成特效代码 \\fscx值'''
    return '\\fscx'+str(scx)

def fscy(scy=0):
    '''生成特效代码 \\fscy值'''
    return '\\fscy'+str(scy)

def fscxy(scxy=0):
    '''生成特效代码 \\fscx值\\fscy值'''
    return '\\fscx'+str(scxy)+'\\fscy'+str(scxy)

def fsc(scxy=0):
    '''生成特效代码 \\fscx值\\fscy值'''
    return '\\fscx'+str(scxy)+'\\fscy'+str(scxy)

def fsp(xs=0):
    '''生成特效代码 \\fsp值'''
    return '\\fso'+str(xs)

def fr(jd=0):
    '''生成特效代码 \\fr值'''
    return '\\fr'+str(jd)

def frx(jd=0):
    '''生成特效代码 \\frx值'''
    return '\\frx'+str(jd)

def frz(jd=0):
    '''生成特效代码 \\frz值'''
    return '\\frz'+str(jd)

def fry(jd=0):
    '''生成特效代码 \\fry值'''
    return '\\fry'+str(jd)

def fe(xs=0):
    '''生成特效代码 \\fe值'''
    return '\\fe'+str(xs)

def c1(cor='FFFFFF'):
    '''生成特效代码 \\1c&H颜色&'''
    if GER_SSA_MAS :
        mas_l.append('\\1c&H'+upper(str(cor))+'&')        
        return '[mas_sta]'+str(len(mas_l)-1)+'[mas_end]'
    else :
        return '\\1c&H'+upper(str(cor))+'&'

def c2(cor='FFFFFF'):
    '''生成特效代码 \\2c&H颜色&'''
    if GER_SSA_MAS :
        mas_l.append('\\42c&H'+upper(str(cor))+'&')        
        return '[mas_sta]'+str(len(mas_l)-1)+'[mas_end]'
    else :
        return '\\2c&H'+upper(str(cor))+'&'

def c3(cor='FFFFFF'):
    '''生成特效代码 \\3c&H颜色&'''
    if GER_SSA_MAS :
        mas_l.append('\\3c&H'+upper(str(cor))+'&')        
        return '[mas_sta]'+str(len(mas_l)-1)+'[mas_end]'
    else :
        return '\\3c&H'+upper(str(cor))+'&'

def c4(cor='FFFFFF'):
    '''生成特效代码 \\4c&H颜色&'''
    if GER_SSA_MAS :
        mas_l.append('\\4c&H'+upper(str(cor))+'&')        
        return '[mas_sta]'+str(len(mas_l)-1)+'[mas_end]'

    else :
        return '\\4c&H'+upper(str(cor))+'&'

def a1(alp = 0):
    '''生成特效代码 \\1a&H透明度&'''
    if GER_SSA_MAS :
        x = hex(alp)[2:5]
        if len(x) < 2 :
            x ='0'+x
        mas_l.append('\\1a&H'+upper(x)+'&')
        
        return '[mas_sta]'+str(len(mas_l)-1)+'[mas_end]'

    else :
        x = hex(alp)[2:5]
        if len(x) < 2 :
            x ='0'+x
        return '\\1a&H'+upper(x)+'&'

def a2(alp = 0):
    '''生成特效代码 \\2a&H透明度&'''
    if GER_SSA_MAS :
        x = hex(alp)[2:5]
        if len(x) < 2 :
            x ='0'+x
        mas_l.append('\\2a&H'+upper(x)+'&')
        
        return '[mas_sta]'+str(len(mas_l)-1)+'[mas_end]'

    else :
        x = hex(alp)[2:5]
        if len(x) < 2 :
            x ='0'+x
        return '\\2a&H'+upper(x)+'&'

def a3(alp = 0):
    '''生成特效代码 \\3a&H透明度&'''
    if GER_SSA_MAS :
        x = hex(alp)[2:5]
        if len(x) < 2 :
            x ='0'+x
        mas_l.append('\\3a&H'+upper(x)+'&')
        
        return '[mas_sta]'+str(len(mas_l)-1)+'[mas_end]'

    else :
        x = hex(alp)[2:5]
        if len(x) < 2 :
            x ='0'+x
        return '\\3a&H'+upper(x)+'&'

def a4(alp = 0):
    '''生成特效代码 \\4a&H透明度&'''
    if GER_SSA_MAS :
        x = hex(alp)[2:5]
        if len(x) < 2 :
            x ='0'+x
        mas_l.append('\\4a&H'+upper(x)+'&')
        
        return '[mas_sta]'+str(len(mas_l)-1)+'[mas_end]'

    else :
        x = hex(alp)[2:5]
        if len(x) < 2 :
            x ='0'+x
        return '\\4a&H'+upper(x)+'&'

def alpha(alp = 0):
    '''生成特效代码 \\alpha&H透明度&'''
    if GER_SSA_MAS :
        
        x = hex(alp)[2:5]
        if len(x) < 2 :
            x ='0'+x
        mas_l.append('\\alpha&H'+upper(x)+'&')
        
        return '[mas_sta]'+str(len(mas_l)-1)+'[mas_end]'

    else :
        x = hex(alp)[2:5]
        if len(x) < 2 :
            x ='0'+x
        return '\\alpha&H'+upper(x)+'&'

def a(wz = 1):
    '''生成特效代码 \\a位置'''
    return '\\a'+str(wz)

def an(wz = 1):
    '''生成特效代码 \\an位置'''
    return '\\an'+str(wz)

def k(kala = 0):
    '''生成特效代码 \\k卡拉'''
    kala = int(kala)
    return '\\k'+str(kala)

def K(kala = 0):
    '''生成特效代码 \\K卡拉'''
    kala = int(kala)
    return '\\K'+str(kala)

def ko(kala = 0):
    '''生成特效代码 \\ko卡拉'''
    kala = int(kala)
    return '\\ko'+str(kala)

def kf(kala = 0):
    '''生成特效代码 \\kf卡拉'''
    kala = int(kala)
    return '\\kf'+str(kala)

def q(kala = 0):
    '''生成特效代码 \\q数'''
    kala = int(kala)
    return '\\q'+str(kala)

def t(tzi = ''):
    '''生成特效代码 \\t(代码)'''
    return '\\t('+str(tzi)+')'

def r(ys=''):
    '''生成特效代码 \\r样式'''
    return '\\r'+str(ys)
 
def move(_sta_pos_x_=0,_sta_pos_y_=0,_end_pos_x_=0,_end_pos_y_=0,_sta_time_=0,_end_time_=0):
    '''生成特效代码 \\move'''
    _sta_pos_x_ = int(_sta_pos_x_)
    _sta_pos_y_ = int(_sta_pos_y_)
    _end_pos_x_ = int(_end_pos_x_)
    _end_pos_y_ = int(_end_pos_y_)
    _sta_time_ = int(_sta_time_)
    _end_time_ = int(_end_time_)
    return move239(_sta_pos_x_,_sta_pos_y_,_end_pos_x_,_end_pos_y_,_sta_time_,_end_time_)

def pos(_pos_x_=0,_pos_y_=0):
    '''生成特效代码 \\pos'''
    _pos_x_ = int(_pos_x_)
    _pos_y_ = int(_pos_y_)
    return '\\pos('+str(_pos_x_)+','+str(_pos_y_)+')'

def org(_org_x_=0,_org_y_=0):
    '''生成特效代码 \\org'''
    _org_x_ = int(_org_x_)
    _orgy_ = int(_org_y_)
    return '\\pos('+str(_org_x_)+','+str(_org_y_)+')'

def fad(in_t=0,out_t=0):
    '''生成特效代码 \\fad'''
    if GER_SSA_MAS :
        mas_l.append('\\fad('+str(in_t)+','+str(out_t)+')')        
        return '[mas_sta]'+str(len(mas_l)-1)+'[mas_end]'
    else :
        in_t = int(in_t)
        out_t = int(out_t)
        return '\\fad('+str(in_t)+','+str(out_t)+')'

def clip(c_x1=0,c_y1=0,c_x2=0,c_y2=0):
    '''生成特效代码 \\clip'''
    c_x1 = int(c_x1)
    c_y1 = int(c_y1)
    c_x2 = int(c_x2)
    c_y2 = int(c_y2)
    return '\\clip('+str(c_x1)+','+str(c_y1)+','+str(c_x2)+','+str(c_y2)+')'

def p(siz=0):
    '''生成特效代码 \\p'''
    siz = int(siz)
    return '\\p'+str(siz)

####################################################################




def mte(str_te = '', str_zi = '', str_te2 = '',str_zi2 = '') :
    '''产生特效文字  类似 {特效}文字{特效}文字'''
    ret = '{'+str_te+'}'+str_zi
    if not str_te2 == '' :
        ret = ret + '{'+str_te2+'}'
    ret = ret + str_zi2+'\n'
    return ret


def mes(typ='Dialogue', lay=0, sta=0, end=0, sty='rom', act='', lef=0, rig=0, ver=0, efe='', tex='') :
    '''产生特效行'''
    dss = '0000'
    if len(str(lef)) < 4 :
        lef = dss[0:4-len(str(lef))]+str(lef)
    if len(str(rig)) < 4 :
        rig = dss[0:4-len(str(rig))]+str(rig)
    if len(str(ver)) < 4 :
        ver = dss[0:4-len(str(ver))]+str(ver)
    ret = ''
    ret = ret + typ+': '
    ret = ret + str(lay)+','
    ret = ret + time2str(sta)+','
    ret = ret + time2str(end)+','
    ret = ret + sty+','
    ret = ret + act+','
    ret = ret + lef+','
    ret = ret + rig+','
    ret = ret + ver+','
    ret = ret + efe+','
    ret = ret + tex
    return ret


def ael(lis_eve=[], to_str='') :
    '''将字符串存入list'''
    lis_eve.append(to_str)

def lef_pos(max_x,an_check,total_x,rl) :
    '''根据对齐方式算出横向时的左边界...视频宽度,对齐方式,行宽,左右边距'''
    qix = 0
    if an_check == 1 :
        qix = rl
    if an_check == 2 :
        qix = max_x/2 - total_x/2
    if an_check == 3 :
        qix = max_x - rl - total_x
    if an_check == 4 :
        qix = max_x/4 - total_x/2
    if an_check == 5 :
        qix = max_x*3/4 - total_x/2
    return qix
    

def conlisval(ziful = []) :
    '''去除空字符之后的总数'''
    aa = 0
    bb = 0
    while aa < len(ziful) :
        if ziful[aa] == '' :
            pass
        else :
            bb = bb+1
        aa =aa+1
    return bb


def top_pos(max_y,an_check,total_y,sx) :
    '''根据对齐方式算出竖向时的上边界...视频高度,对齐方式,行高,上下边距'''
    qiy = 0
    if an_check == 1 :
        qiy = sx
    if an_check == 2 :
        qiy = max_y/2 - total_y/2
    if an_check == 3 :
        qiy = max_y - sx - total_y
    if an_check == 4 :
        qiy = max_x/4 - total_y/2
    if an_check == 5 :
        qiy = max_y*3/4 - total_y/2
    return qiy


def xy_pos(zi_kuan, zi_gao, CON_ACU_CAR, COL_ACU_CAR, LIN_ACU_CAR, COL_INI_CAR, LIN_INI_CAR, ALI_SIL_KAR, LIN_FRA_KAR, COL_FRA_KAR, GER_FRA_HOR) :
    '''最终计算出x,y的pos值...字宽,字高,运行次数,横向积累值,竖向积累值,左边界值,上边界值,定位方式,水平x值,竖直y值,横竖控制'''
    if GER_FRA_HOR :
        jiajia = 0
        if ALI_SIL_KAR in [2,5,8] :
            jiajia = zi_kuan/2
        if ALI_SIL_KAR in [3,6,9] :
            jiajia = zi_kuan
        pos_x = COL_INI_CAR + COL_ACU_CAR + jiajia
        pos_y = LIN_FRA_KAR
        COL_ACU_CAR = COL_ACU_CAR + zi_kuan
    else :
        jiajia = 0
        if ALI_SIL_KAR in [4,5,6] :
            jiajia = zi_gao/2
        if ALI_SIL_KAR in [1,2,3] :
            jiajia = zi_gao
        pos_x = COL_FRA_KAR
        pos_y = LIN_INI_CAR + LIN_ACU_CAR + jiajia
        LIN_ACU_CAR = LIN_ACU_CAR + zi_gao
        
    CON_ACU_CAR = CON_ACU_CAR + 1

    return(pos_x,pos_y,COL_ACU_CAR,LIN_ACU_CAR,CON_ACU_CAR)


def out_ass(fil, mas_fil, GER_SSA_MAS, start_time, LIS_CAB_COM, LIS_EST_PRI, LIS_EST_MAS, LIS_EST_COM, LIS_EVE_FRE, UNI) :
    '''生成ass'''
    print u'\n脚本生成进行中'
    fil = fil.decode("utf-8")
    mas_fil = mas_fil.decode("utf-8")

    if UNI == 1 :
        wr = codecs.open(fil, "w", "utf-16")
    else :
        wr = open(fil,"w")
    if GER_SSA_MAS :
        if NUI ==1 :
            maswr = codecs.open(mas_fil,"w", "utf-16")
        else :
            maswr = open(mas_fil,"w")
    
    total = LIS_CAB_COM + LIS_EST_PRI + LIS_EST_COM

    num1 = len(total)
    num2 = len(LIS_EVE_FRE)
    
    for x in total :
        if UNI == 1 :
            x=x.replace('\n','\r\n').decode("utf-8")
        wr.write(x)

    print u'产生头信息: '+str(num1) +u' 行'


    if GER_SSA_MAS :
        total = LIS_CAB_COM + LIS_EST_MAS + LIS_EST_COM
        for x in total :
            if UNI == 1 :
                x=x.replace('\n','\r\n').decode("utf-8")
            maswr.write(x)

        print u'产生MASK头信息: '+str(num1) +u' 行'

    for x in LIS_EVE_FRE :
        
        if GER_SSA_MAS :
            tos = ''
            mass = ''
            if not x.find('[mas_sta]')==-1 :
                tolis = x.split('[mas_sta]')
                for s in tolis :
                    if s.find('[mas_end]')==-1 :
                        tos = tos+s
                        mass = mass +s
                    else :
                        liss = s.split('[mas_end]')
                        
                        if ltrim(mas_l[int(liss[0])],4) in ['\\1c&','\\2c&','\\3c&','\\4c&'] :
                            tos = tos + mas_l[int(liss[0])]+liss[1]
                            mass = mass + ltrim(mas_l[int(liss[0])],5)+'000000&'+liss[1]
                        elif ltrim(mas_l[int(liss[0])],4) in ['\\1a&','\\2a&','\\3a&','\\4a&'] :
                            tos = tos + ltrim(mas_l[int(liss[0])],5)+'00&'+liss[1]
                            mass = mass + mas_l[int(liss[0])] + liss[1]
                        elif ltrim(mas_l[int(liss[0])],4) in ['\\alp'] :
                            tos = tos +'\\alpha&H00&'+liss[1]
                            mass = mass + mas_l[int(liss[0])] + liss[1]
                        else :
                            tos = tos + liss[1]
                            mass = mass + mas_l[int(liss[0])] + liss[1]
                if UNI == 1 :
                    tos=tos.replace('\n','\r\n').decode("utf-8")
                    mass=mass.replace('\n','\r\n').decode("utf-8")
                wr.write(tos)
                maswr.write(mass)
            else :
                if UNI == 1 :
                    x=x.replace('\n','\r\n').decode("utf-8")
                wr.write(x)
                maswr.write(x)
        else :
            if UNI == 1 :
                x=x.replace('\n','\r\n').decode("utf-8")
            wr.write(x)

    wr.close()
    if GER_SSA_MAS :
        maswr.close()
    print u'产生特效: '+str(num2) +u' 行'
    print fil+u' 成功生成 ('+str(num1+num2)+u' 行)\n'

    if GER_SSA_MAS :
        print u'产生MASK特效: '+str(num2) +u' 行'
        print mas_fil+u' 成功生成 ('+str(num1+num2)+u' 行)\n'
    
    print str(num1+num2)+u' 行 生成用时 '+time2str(int((time()-start_time)*100))