Permalink
Switch branches/tags
Find file
Fetching contributors…
Cannot retrieve contributors at this time
executable file 1819 lines (1482 sloc) 52.3 KB
#!/usr/bin/env python2
# -*- coding: UTF-8 -*-
# Copyright 2006-2009 (C) Raster Software Vigo (Sergio Costas)
# Copyright 2006-2009 (C) Peter Gill - win32 parts
# This file is part of DeVeDe
#
# DeVeDe is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# DeVeDe is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import os
import stat
import pygtk # for testing GTK version number
pygtk.require ('2.0')
import gtk
import gobject
import sys
import gc
import copy
import time
import devede_other
import devede_executor
import devede_convert
import devede_dialogs
import devede_help
import math
# How to add new file options:
# In the class NEWFILE, method CREATE_DEFAULT_VIDEO_PARAMETERS, add the new option
# to the SELF.FILE_PROPERTIES dictionary, setting its default value based in the
# SELF.FILE_VALUES values (the ones obtained with MPLAYER --IDENTIFY), SELF.PAL (True
# for PAL output video, False for NTSC output video) and SELF.DISCTOCREATE (DVD, VCD, SVCD
# CVD or DIVX)
# In the class FILE_PROPERTIES
# In the method GET_WIDGETS, set the parameter value in the SELF.FILE_PROPERTIES
# dictionary using the widget's current value
# In the method SET_WIDGETS, set the widget's value using the parameter value in
# SELF.FILE_PROPERTIES
# If the widget must be disabled or enabled under some circumstances (other widgets)
# set that code in method SET_FILM_BUTTONS
#
# Finally, add the needed code in DEVEDE_LOADSAVE.PY to ensure that old project files
# work fine with the new options
class file_get_params(devede_executor.executor):
def read_file_values(self,filename,check_audio):
""" Reads the values of the video (width, heigth, fps...) and stores them
into file_values.
Returns (False,AUDIO) if the file is not a video (with AUDIO the number
of audio tracks)
Returns (True,0) if the file is a right video file """
handler=''
vrate=0
arate=0
width=0
height=0
fps=0
length=0
audio=0
video=0
audiorate=0
aspect_ratio=1.3333333333
self.length=0
# if CHECK_AUDIO is TRUE, we just check if it's an audio file
if check_audio:
nframes=0
else:
nframes=1
if (sys.platform=="win32") or (sys.platform=="win64"):
command="mplayer.exe"
else:
command="mplayer"
launcher=[command, "-loop","1","-identify", "-ao", "null", "-vo", "null", "-frames", str(nframes), filename]
handler=self.launch_program(launcher, win32arg=False,with_stderr=False)
minimum_audio=10000
audio_list=[]
while True:
linea=handler.stdout.readline()
linea=self.remove_ansi(linea)
if linea=="":
break
position=linea.find("ID_")
if position==-1:
continue
linea=linea[position:]
if linea[:16]=="ID_VIDEO_BITRATE":
vrate=int(linea[17:])
if linea[:14]=="ID_VIDEO_WIDTH":
width=int(linea[15:])
if linea[:15]=="ID_VIDEO_HEIGHT":
height=int(linea[16:])
if linea[:15]=="ID_VIDEO_ASPECT":
aspect_ratio=float(linea[16:])
if linea[:12]=="ID_VIDEO_FPS":
fps2=linea[13:]
while ord(fps2[-1])<32:
fps2=fps2[:-1]
posic=linea.find(".")
if posic==-1:
fps=int(linea[13:])
else:
fps=int(linea[13:posic])
if linea[posic+1]=="9":
fps+=1
if linea[:16]=="ID_AUDIO_BITRATE":
arate=int(linea[17:])
if linea[:13]=="ID_AUDIO_RATE":
audiorate=int(linea[14:])
if linea[:9]=="ID_LENGTH":
length=int(float(linea[10:]))
if linea[:11]=="ID_VIDEO_ID":
video+=1
if linea[:11]=="ID_AUDIO_ID":
audio+=1
audio_track=int(linea[12:])
if minimum_audio>audio_track:
minimum_audio=audio_track
audio_list.append(audio_track)
handler.wait()
if (video==0) or (width==0) or (height==0):
if (audio!=0):
self.length=length
self.audio=audio
return False,audio
if aspect_ratio==0.0 or math.isnan(aspect_ratio) :
aspect_ratio=(float(width))/(float(height))
if aspect_ratio<=1.5:
aspect_ratio=(4.0/3.0)
self.file_values={}
self.file_values["vrate"]=vrate
self.file_values["arate"]=arate
self.file_values["video_streams"]=video
self.file_values["audio_streams"]=audio
self.file_values["width"]=width
self.file_values["height"]=height
self.file_values["fps"]=fps
self.file_values["ofps2"]=fps2
self.file_values["length"]=length
self.file_values["aspect_ratio"]=aspect_ratio
self.file_values["audiorate"]=audiorate
self.file_values["audio_list"]=audio_list
self.file_values["audio_stream"]=minimum_audio
return True,0
class newfile(file_get_params):
def __init__(self,pal,disctocreate):
""" This class manages every new film added. It reads its parameters (resolution, FPS, number of
channels...) and allows to generate the default values, both when choosing manually a file from the
Properties window, or when dragging&dropping them into the main window """
file_get_params.__init__(self)
self.pal=pal
self.disctocreate=disctocreate
self.file_values=None
self.file_properties=None
def get_recomended_resolution(self,vrate,arate,desired_resolution):
""" Returns the recomended resolution for a video based in its original
resolution and the resolution chosed by the user.
DESIRED_RESOLUTION is a value from 0 to 7:
0=auto, 1=720x480, 2=704x480, 3=480x480, 4=352x480, 5=352x240
6=1280x720, 7=1920x1080, 8 160x128
It returns the recomended audio and video rate for that resolution,
but only if the user hasn't changed them """
if self.pal:
nheigh1=576
nheigh2=288
else:
nheigh1=480
nheigh2=240
if self.file_values==None:
return 0,0,False,0,0
if desired_resolution==0: # default resolution; we have to take the most similar resolution
if self.disctocreate=="vcd":
resx=352
resy=nheigh2
elif self.disctocreate=="cvd":
resx=352
resy=nheigh1
elif self.disctocreate=="svcd":
resx=480
resy=nheigh1
else: # dvd o divx
if self.file_values["width"]<=352:
resx=352
if self.file_values["height"]<=nheigh2:
resy=nheigh2
else:
resy=nheigh1
else:
resx=720
resy=nheigh1
elif desired_resolution==1:
resx=720
resy=nheigh1
elif desired_resolution==2:
resx=704
resy=nheigh1
elif desired_resolution==3:
resx=480
resy=nheigh1
elif desired_resolution==4:
resx=352
resy=nheigh1
elif desired_resolution==5:
resx=352
resy=nheigh2
elif desired_resolution==6:
resx=1280
resy=720
elif desired_resolution==7:
resx=1920
resy=1080
elif desired_resolution==8:
resx=160
resy=128
if (((resx==720) and (resy==nheigh1)) or ((self.disctocreate=="divx") and (desired_resolution!=8))) and (self.file_values["aspect_ratio"]>=1.77):
use_widescreen=True
else:
use_widescreen=False
if (vrate==5001) or (vrate==3001) or (vrate==2001):
if (resx>703):
vrate=5001
if (resx==480) or ((resx==352) and (resy==nheigh1)):
vrate=3001
if (resx==352) and (resy==nheigh2):
vrate=2001
if (self.disctocreate!="dvd") and (self.disctocreate!="divx"):
vrate=2001
if self.disctocreate=="vcd":
vrate=1152
arate=224
return resx,resy,use_widescreen,vrate,arate
def create_default_video_parameters(self,filename):
""" This method fills the FILE_PROPERTIES property with the default values for the file.
It returns False if the file isn't a valid video. The tuple contains the number of sound
tracks found, so if it's different from 0, its an audio-only file. """
if filename==None:
return False,0
isvideo,audio_tracks=self.read_file_values(filename,True)
if isvideo==False:
return False,audio_tracks
isvideo,audio_tracks=self.read_file_values(filename,False) # get all the values in FILE_VALUES
while filename[-1]==os.sep:
filename=filename[:-1]
nombre=filename
while True: # get the filename without the path
posic=nombre.find(os.path.sep)
if posic==-1:
break
else:
nombre=nombre[posic+1:]
# filename[0]; path[1]; width[2]; heigh[3]; length[4] (seconds); original fps[5];
# original videorate["oarate"]; original audiorate[7];
# final videorate[8]; final arate[9]; final width[10]; final heigh[11];
# 0=Black bars, 1=Scale picture [12];
# length of chapters[13]; audio delay["fps"]; final fps["arateunc"]; original audio rate (uncompressed)["oaspect"];
# original aspect ratio[17]; final aspect ratio[18];
# 0=full length, 1=first half, 2=second half [19];
# Resolution: 0=auto, 1=720x480, 2=704x480, 3=480x480, 4=352x480, 5=352x240, 6=1280x720, 7=1920x1080 [20]
# extra parameters [21]
self.file_properties={}
self.file_properties["filename"]=nombre # filename without path
self.file_properties["path"]=filename # file with complete path
self.file_properties["owidth"]=self.file_values["width"] # original width
self.file_properties["oheight"]=self.file_values["height"] # original height
self.file_properties["olength"]=self.file_values["length"] # original length (in seconds)
self.file_properties["ovrate"]=self.file_values["vrate"]/1000 # original videorate (in kbytes/second)
self.file_properties["oarate"]=self.file_values["arate"]/1000 # original audiorate (in kbytes/second)
self.file_properties["arateunc"]=self.file_values["audiorate"] # original uncompressed audiorate
self.file_properties["oaspect"]=self.file_values["aspect_ratio"] # original aspect ratio
self.file_properties["audio_list"]=self.file_values["audio_list"][:]
self.file_properties["audio_stream"]=self.file_values["audio_stream"]
if self.pal:
self.file_properties["fps"]=25
else:
self.file_properties["fps"]=30
self.file_properties["ofps"]=self.file_values["fps"]
self.file_properties["ofps2"]=self.file_values["ofps2"]
self.file_properties["blackbars"]=self.global_vars["file_blackbars"] # black bars, no scale
self.file_properties["lchapters"]=self.global_vars["file_lchapters"]
self.file_properties["adelay"]=0 # no audio delay
self.file_properties["cutting"]=0 # full length
self.file_properties["resolution"]=0 # output resolution = auto
self.file_properties["params"]="" # no mencoder extra parameters
self.file_properties["params_vf"]="" # no mencoder extra VF parameters
self.file_properties["params_lavc"]="" # no mencoder extra LAVC parameters
self.file_properties["params_lame"]="" # no mencoder extra LAME parameters
self.file_properties["ismpeg"]=False # is already an MPEG-2 compliant file
self.file_properties["copy_audio"]=False # recompress the audio
self.file_properties["isvob"]=False # recompress both audio and video
self.file_properties["swap_fields"]=False # swap fields in interlaced videos
self.file_properties["sub_fill_color"]=[65535,65535,65535,65535] # subtitle outline color
self.file_properties["sub_outline_color"]=[0,0,0,65535] # subtitle outline color
self.file_properties["subfont_size"]=28 # subtitle font size
self.file_properties["sound51"]=self.global_vars["file_sound51"] # don't use 5.1 sound
self.file_properties["gop12"]=True # GOP of 12 by default to increase compatibility
self.file_properties["filesize"]=os.stat(filename)[stat.ST_SIZE] # file size
self.file_properties["trellis"]=True # use trellis
self.file_properties["twopass"]=self.global_vars["file_twopass"] # two pass encoding
self.file_properties["turbo1stpass"]=self.global_vars["file_turbo1stpass"] # use turbo 1st pass on two pass encoding
self.file_properties["mbd"]=2 # maximum quality
self.file_properties["deinterlace"]="none" # don't deinterlace
self.file_properties["sub_list"]=[]
self.file_properties["force_subs"]=False
resx,resy,use_widescreen,vrate,arate=self.get_recomended_resolution(5001, 224, 0)
self.file_properties["width"]=resx
self.file_properties["height"]=resy
self.file_properties["vrate"]=vrate
self.file_properties["arate"]=arate
self.file_properties["rotate"]=0 # no rotation
self.file_properties["hmirror"]=False
self.file_properties["vmirror"]=False
if use_widescreen:
self.file_properties["aspect"]=1.7777777
else:
self.file_properties["aspect"]=1.3333333
self.file_properties["volume"]=self.global_vars["file_volume"]
return True,audio_tracks
def split_dnd(self,data):
""" Takes the list of files dragged into the window and returns them in a list """
lista=[]
item=""
tempo=""
mode=0
if (sys.platform=="win32") or (sys.platform=="win64"):
length=8
else:
length=7
cadena2=""
for elemento in data:
if (ord(elemento)<32):
cadena2+="\n"
else:
cadena2+=elemento
while(True):
pos=cadena2.find("file:///")
if (pos==-1):
break
pos2=cadena2.find("\n",pos)
if (pos2==-1):
cadena=cadena2[pos+length:]
cadena2=""
else:
cadena=cadena2[pos+length:pos2]
cadena2=cadena2[pos2:]
while (True):
pos=cadena.find("%")
if (pos==-1):
break
cadena=cadena[:pos]+chr(int(cadena[pos+1:pos+3],16))+cadena[pos+3:]
lista.append(cadena)
print "Dragged files: "+str(lista)
return lista
##################################################################################
class file_properties(newfile):
""" This class manages the properties window, where the user can choose the properties
of each video file """
def motion_cb(self,wid, context, x, y, time):
context.drag_status(gtk.gdk.ACTION_COPY, time)
return True
def drop_cb(self, wid, context, x, y, time):
# Used with windows drag and drop
print 'drop'
self.have_drag = False
if context.targets:
wid.drag_get_data(context, context.targets[0], time)
return True
return False
# public methods
def __init__(self,global_vars,title,chapter,structure,callback_refresh):
newfile.__init__(self,global_vars["PAL"],global_vars["disctocreate"])
self.gladefile=global_vars["gladefile"]
self.global_vars=global_vars
self.title=title
self.chapter=chapter
self.structure=structure
self.callback_refresh=callback_refresh
self.tree=devede_other.create_tree(self,"wfile",self.gladefile)
self.window=self.tree.get_object("wfile")
self.window.show()
self.window.drag_dest_set(0,[],0)
self.window.connect('drag_drop', self.drop_cb)
self.window.connect('drag_motion', self.motion_cb)
w = self.tree.get_object("expander_advanced")
w.set_expanded(self.global_vars["expand_advanced"])
if global_vars["PAL"]:
w=self.tree.get_object("video_pal")
else:
w=self.tree.get_object("video_ntsc")
w.set_active(True)
# Model and view for subtitles
# first element: position
# second: filename
# third: codepage
self.sub_model=gtk.ListStore(gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING)
self.sub_tree=self.tree.get_object("sub_treeview")
self.sub_tree.set_model(self.sub_model)
render1=gtk.CellRendererText()
column1=gtk.TreeViewColumn(_("Subtitle"),render1,text=1)
self.sub_tree.append_column(column1)
render2=gtk.CellRendererText()
column2=gtk.TreeViewColumn(_("Codepage"),render2,text=2)
self.sub_tree.append_column(column2)
render3=gtk.CellRendererText()
column3=gtk.TreeViewColumn(_("Language"),render3,text=3)
self.sub_tree.append_column(column3)
# Model and view for audio tracks
self.audio_model=gtk.ListStore(gobject.TYPE_STRING)
self.audio_view=self.tree.get_object("audiotrack")
self.audio_view.set_model(self.audio_model)
audiorender=gtk.CellRendererText()
self.audio_view.pack_start(audiorender,True)
self.audio_view.add_attribute(audiorender,"text",0)
w1 = self.tree.get_object("subtitles_label")
w2 = self.tree.get_object("frame_special")
w3 = self.tree.get_object("gop12")
w4 = self.tree.get_object("res1280x720")
w5 = self.tree.get_object("res1920x1080")
w6 = self.tree.get_object("subtitles_list")
w7 = self.tree.get_object("res160x128")
if (self.disctocreate == "divx"):
w1.show()
w2.hide()
w3.hide()
w4.show()
w5.show()
w6.hide()
w7.show()
else:
w1.hide()
w2.show()
w3.show()
w4.hide()
w5.hide()
w6.show()
w7.hide()
w=self.tree.get_object("noaudiotracks")
w.hide()
w=self.tree.get_object("file_split_frame")
if (self.disctocreate=="vcd") or (self.disctocreate=="svcd") or (self.disctocreate=="cvd"):
w.show()
else:
w.hide()
w = self.tree.get_object("frame_division") # SPLIT THE FILES IN CHAPTERS FOR EASY SEEKING
if (self.disctocreate == "dvd"):
w.show()
else:
w.hide()
self.set_resolution()
self.change_file=False
if (self.chapter!=-1): # we want to modify a chapter
the_chapter=structure[title][chapter]
print "Chequeo "+str(the_chapter["path"])
isvideo,audio_tracks=self.read_file_values(the_chapter["path"],True)
if isvideo==True:
self.read_file_values(the_chapter["path"],False) # get all the values in FILE_VALUES
self.file_properties=copy.deepcopy(the_chapter)
self.change_file=True # we are changing the file name manually
w=self.tree.get_object("moviefile")
print "Pongo nombre por propiedades"
w.set_filename(self.file_properties["path"])
else:
w1.set_sensitive(False)
else:
if (self.global_vars["filmpath"]!=""):
w=self.tree.get_object("moviefile")
w.set_current_folder(self.global_vars["filmpath"])
w=self.tree.get_object("moviefile")
self.file_filter_videos=gtk.FileFilter()
self.file_filter_videos.set_name(_("Video files"))
if (sys.platform!="win32") and (sys.platform!="win64"):
self.file_filter_videos.add_mime_type("video/*")
self.file_filter_videos.add_pattern("*.rmvb")
else:
self.file_filter_videos.add_custom(gtk.FILE_FILTER_FILENAME|gtk.FILE_FILTER_DISPLAY_NAME, self.custom_video_filter)
self.file_filter_all=gtk.FileFilter()
self.file_filter_all.set_name(_("All files"))
self.file_filter_all.add_pattern("*")
print "Anado filtro"
w.add_filter(self.file_filter_videos)
print "Anado filtro"
w.add_filter(self.file_filter_all)
self.set_widgets()
if (self.chapter!=-1): # we want to modify a chapter
self.set_global_values()
self.set_film_buttons()
if (self.chapter!=-1): # we want to modify a chapter
print "Modificando"
w=self.tree.get_object("fileaccept")
w.set_sensitive(True)
w=self.tree.get_object("preview_film")
w.set_sensitive(True)
print "Fin"
# help methods
def custom_video_filter(self, filter_info=None, data=None):
"""Custom file filter. Filter for video files when running on win32"""
video_types=["m2ts","wmv", "avi", "asf", "flv", "bin", "vob", "es", "ps", "pes","qt", "mov", "mp4", "mpg", "mpeg", "rm", "mkv", "nut", "nsv", "vivo", "fli", "yuv4mpeg", "cpk","ogm", "asx", "3gp"]
if os.path.splitext(filter_info[2])[1][1:] in video_types:
return True
return False
def get_desired_resolution(self):
""" Returns the resolution desired by the user as a single number """
if (self.tree.get_object("res160x128").get_active()):
return 8
if (self.tree.get_object("res1920x1080").get_active()):
return 7
if (self.tree.get_object("res1280x720").get_active()):
return 6
if (self.tree.get_object("res720x480").get_active()):
return 1
if (self.tree.get_object("res704x480").get_active()):
return 2
if (self.tree.get_object("res480x480").get_active()):
return 3
if (self.tree.get_object("res352x480").get_active()):
return 4
if (self.tree.get_object("res352x240").get_active()):
return 5
return 0
def adjust_resolution(self):
""" Sets the final resolution and bitrate based on the original resolution and the
desired one by the user """
if self.file_properties==None:
return
w1=self.tree.get_object("video_rate")
vrate=w1.get_value()
w2=self.tree.get_object("audio_rate")
arate=w2.get_value()
resx,resy,use_widescreen,vrate,arate=self.get_recomended_resolution(vrate, arate, self.get_desired_resolution())
self.file_properties["width"]=resx
self.file_properties["height"]=resy
w1.set_value(vrate)
w2.set_value(arate)
w=self.tree.get_object("aspect_ratio_4_3")
if ((resx<720) or (resy<480)) and (self.disctocreate!="divx"):
w.set_active(True)
if w.get_active():
self.file_properties["aspect"]=1.3333333
else:
self.file_properties["aspect"]=1.7777777
def get_widgets(self):
""" Fills the file_properties list with the values expressed in the widgets """
if len(self.file_properties["audio_list"])>0:
w=self.tree.get_object("audiotrack")
pos=w.get_active()
if (pos==-1):
pos=0
self.file_properties["audio_stream"]=self.file_properties["audio_list"][pos]
w=self.tree.get_object("force_subs")
self.file_properties["force_subs"]=w.get_active()
w=self.tree.get_object("blackbars")
if w.get_active():
self.file_properties["blackbars"]=0
else:
self.file_properties["blackbars"]=1
w=self.tree.get_object("trell")
self.file_properties["trellis"]=w.get_active()
w=self.tree.get_object("twopass")
self.file_properties["twopass"]=w.get_active()
w=self.tree.get_object("turbo1stpass")
self.file_properties["turbo1stpass"]=w.get_active()
self.file_properties["mbd"]=0
w=self.tree.get_object("mbd1")
if w.get_active():
self.file_properties["mbd"]=1
w=self.tree.get_object("mbd2")
if w.get_active():
self.file_properties["mbd"]=2
self.file_properties["deinterlace"]="none"
w=self.tree.get_object("deinterlace_lb")
if w.get_active():
self.file_properties["deinterlace"]="lb"
w=self.tree.get_object("deinterlace_md")
if w.get_active():
self.file_properties["deinterlace"]="md"
w=self.tree.get_object("deinterlace_fd")
if w.get_active():
self.file_properties["deinterlace"]="fd"
w=self.tree.get_object("deinterlace_l5")
if w.get_active():
self.file_properties["deinterlace"]="l5"
w=self.tree.get_object("deinterlace_yadif")
if w.get_active():
self.file_properties["deinterlace"]="yadif"
w=self.tree.get_object("ismpeg")
self.file_properties["ismpeg"]=w.get_active()
self.file_properties["swap_fields"]=self.tree.get_object("swap_fields").get_active()
w=self.tree.get_object("copy_audio")
self.file_properties["copy_audio"]=w.get_active()
w=self.tree.get_object("isvob")
self.file_properties["isvob"]=w.get_active()
w=self.tree.get_object("sound51")
self.file_properties["sound51"]=w.get_active()
w=self.tree.get_object("gop12")
self.file_properties["gop12"]=w.get_active()
w=self.tree.get_object("do_chapters")
if w.get_active():
w=self.tree.get_object("chapter_long")
self.file_properties["lchapters"]=w.get_value()
else:
self.file_properties["lchapters"]=0
w=self.tree.get_object("subfont_size")
self.file_properties["subfont_size"]=int(w.get_value())
w=self.tree.get_object("sub_fill_color")
color=w.get_color()
self.file_properties["sub_fill_color"]=[color.red,color.green,color.blue,w.get_alpha()]
w=self.tree.get_object("sub_outline_color")
color=w.get_color()
self.file_properties["sub_outline_color"]=[color.red,color.green,color.blue,w.get_alpha()]
w=self.tree.get_object("audiodelay")
self.file_properties["adelay"]=float(w.get_value())
w=self.tree.get_object("video_rate")
self.file_properties["vrate"]=int(w.get_value())
w=self.tree.get_object("audio_rate")
self.file_properties["arate"]=int(w.get_value())
w=self.tree.get_object("volume_adj")
self.file_properties["volume"]=int(w.get_value())
w=self.tree.get_object("full_length")
if w.get_active():
self.file_properties["cutting"]=0
else:
w=self.tree.get_object("first_half")
if w.get_active():
self.file_properties["cutting"]=1
else:
self.file_properties["cutting"]=2
w=self.tree.get_object("video_pal")
if w.get_active():
self.file_properties["fps"]=25
else:
self.file_properties["fps"]=30
if (self.disctocreate=="dvd") or (self.disctocreate=="divx"):
w=self.tree.get_object("aspect_ratio_16_9")
if w.get_active():
self.file_properties["aspect"]=1.77777777
else:
self.file_properties["aspect"]=1.33333333
else:
self.file_properties["aspect"]=1.33333333
self.file_properties["resolution"]=self.get_desired_resolution()
w=self.tree.get_object("custom_params")
self.file_properties["params"]=w.get_text()
w=self.tree.get_object("custom_params_vf")
self.file_properties["params_vf"]=w.get_text()
w=self.tree.get_object("custom_params_lavcopts")
self.file_properties["params_lavc"]=w.get_text()
if (self.disctocreate=="divx"):
w=self.tree.get_object("custom_params_lameopts")
self.file_properties["params_lame"]=w.get_text()
w=self.tree.get_object("rotation0")
if w.get_active():
self.file_properties["rotate"]=0 # no rotation
w=self.tree.get_object("rotation90")
if w.get_active():
self.file_properties["rotate"]=90 # rotate 90 degrees clockwise
w=self.tree.get_object("rotation180")
if w.get_active():
self.file_properties["rotate"]=180 # rotate 180 degrees
w=self.tree.get_object("rotation270")
if w.get_active():
self.file_properties["rotate"]=270 # rotate 90 degrees counter-clockwise
w=self.tree.get_object("hmirror")
self.file_properties["hmirror"]=w.get_active()
w=self.tree.get_object("vmirror")
self.file_properties["vmirror"]=w.get_active()
# Callbacks
def on_reset_volume_clicked(self,widget):
w=self.tree.get_object("volume_adj")
w.set_value(100)
def on_sub_add_clicked(self,widget):
window=ask_subtitle(self.gladefile,self.global_vars["filmpath"],self.global_vars)
ret=window.run()
window=None
if ret!=None:
self.file_properties["sub_list"].append(ret)
self.refresh_subtitles()
self.set_global_values()
def on_sub_remove_clicked(self,widget):
w=self.tree.get_object("sub_treeview")
try:
ctree,iter=w.get_selection().get_selected()
subtitle=ctree.get_value(iter,0)
except:
subtitle=-1
if subtitle==-1:
return
newtree=devede_other.create_tree(self,"wdel_subtitle",self.gladefile,False)
window=newtree.get_object("wdel_subtitle")
window.show()
ret=window.run()
window.hide()
window.destroy()
window=None
newtree=None
if ret==-5:
del (self.file_properties["sub_list"])[subtitle]
self.refresh_subtitles()
self.set_global_values()
def on_filecancel_clicked(self,widget):
w=self.tree.get_object("expander_advanced")
self.global_vars["expand_advanced"]=w.get_expanded()
self.window.destroy()
self.window=None
gc.collect()
def on_fileaccept_clicked(self,widget):
w=self.tree.get_object("expander_advanced")
self.global_vars["expand_advanced"]=w.get_expanded()
self.get_widgets()
if self.chapter==-1: # add this file as a new chapter
self.structure[self.title].append(self.file_properties)
else:
self.structure[self.title][self.chapter]=self.file_properties
self.window.destroy()
self.window=None
(self.callback_refresh)()
gc.collect()
def on_wfile_delete_event(self,widget,arg2):
self.window.destroy()
self.window=None
gc.collect()
return True
def on_wfile_destroy_event(self,widget,arg2):
self.window.destroy()
self.window=None
gc.collect()
def on_clear_subtitles_clicked(self,widget):
""" clears the subtitle filechooser """
w=self.tree.get_object("subtitles_chooser")
w.unselect_all()
def on_moviefile_file_set(self,widget):
w=self.tree.get_object("moviefile")
filename=widget.get_filename()
print "File changed to "+str(filename)
if (filename==None) or (filename==""):
self.set_widgets()
self.set_global_values()
self.set_film_buttons()
return
self.global_vars["filmpath"]=os.path.split(filename)[0]
if self.change_file:
self.set_widgets()
self.set_global_values()
self.set_film_buttons()
self.change_file=False
return
fine,tracks=self.create_default_video_parameters(filename)
if fine==False: # it's not a video file
if tracks==0: # it's not a multimedia file
devede_dialogs.show_error(self.gladefile,_("File doesn't seem to be a video file."))
else:
devede_dialogs.show_error(self.gladefile,_("File seems to be an audio file."))
w.unselect_all()
self.set_widgets()
self.set_global_values()
self.set_film_buttons()
def on_video_pal_toggled(self,widget):
""" Detects the change in the option PAL/NTSC """
w=self.tree.get_object("video_pal")
self.pal=w.get_active()
self.set_resolution()
self.adjust_resolution()
self.set_global_values()
def on_res_toggled(self,widget):
self.adjust_resolution()
self.set_global_values()
self.set_film_buttons()
def on_length_toggled(self,widget):
self.set_global_values()
def on_video_rate_value_changed(self,widget):
self.set_global_values()
def on_audio_rate_value_changed(self,widget):
self.set_global_values()
def on_subtitles_chooser_selection_changed(self,widget):
self.set_global_values()
def on_aspect_ratio_toggled(self,widget):
if self.file_properties==None:
return
w=self.tree.get_object("aspect_ratio_16_9")
if w.get_active()==False:
return
self.set_resolution()
if (self.file_properties["width"]<720) or (self.file_properties["height"]<480):
w=self.tree.get_object("res720x480")
w.set_active(True)
def on_ismpeg_toggled(self,widget):
self.set_film_buttons()
self.set_global_values()
def on_copy_audio_toggled(self,widget):
self.set_film_buttons()
self.set_global_values()
def on_isvob_toggled(self,widget):
self.set_film_buttons()
self.set_global_values()
def on_twopass_toggled(self,widget):
w = self.tree.get_object("turbo1stpass")
if widget.get_active():
w.set_sensitive(True)
else:
w.set_active(False)
w.set_sensitive(False)
def on_sound51_toggled(self,widget):
self.set_film_buttons()
self.set_global_values()
def on_preview_film_clicked(self,widget):
self.get_widgets()
self.global_vars["erase_temporary_files"]=True
self.global_vars["number_actions"]=1
tmp_structure=[["",self.file_properties]]
converter=devede_convert.create_all(self.gladefile,tmp_structure,self.global_vars,self.callback)
converter.preview(self.global_vars["temp_folder"])
def on_file_help_clicked(self,widget):
help_class=devede_help.show_help(self.gladefile,self.global_vars["help_path"],"file.html")
def callback(self):
""" This method is called after a preview """
return None # do nothing
def draganddrop(self,widget,drag_context, x, y, selection, info, time):
""" Manages the Drag&Drop in the property window """
sub_extensions3=[".sub",".srt",".ssa",".smi",".txt",".aqt",".jss", ".ass"]
sub_extensions2=[".rt",".js"]
lista=self.split_dnd(selection.data)
if len(lista)==0:
return
if len(lista)>1:
devede_dialogs.show_error(self.gladefile,_("Please, add only one file each time."))
return
if self.disctocreate!="divx":
print("Entro en subs")
filename=str(lista[0]).lower()
if len(filename)>=4:
extension3=filename[-4:]
extension2=filename[-3:]
print "Extensiones: "+str(extension3)+" "+str(extension2)
if (0!=sub_extensions3.count(extension3)) or (0!=sub_extensions2.count(extension2)): # is a subtitle
current_file=self.tree.get_object("moviefile").get_filename()
if (current_file=="") or (current_file==None):
devede_dialogs.show_error(self.gladefile,_("Please, add a movie file before adding subtitles."))
return
window=ask_subtitle(self.gladefile,self.global_vars["filmpath"],self.global_vars,lista[0])
ret=window.run()
window=None
if ret!=None:
self.file_properties["sub_list"].append(ret)
self.refresh_subtitles()
self.set_global_values()
return
w=self.tree.get_object("moviefile")
print "Adding "+str(lista[0])
w.set_filename(str(lista[0]))
# data visualization methods
def set_resolution(self):
""" Sets the labels with the rigth resolution values, depending
if the user selected PAL/SECAM or NTSC """
if self.pal:
res1="288"
res2="576"
else:
res1="240"
res2="480"
w=self.tree.get_object("res720x480")
w.set_label("720x"+res2)
w=self.tree.get_object("res704x480")
w.set_label("704x"+res2)
w=self.tree.get_object("res480x480")
w.set_label("480x"+res2)
w=self.tree.get_object("res352x480")
w.set_label("352x"+res2)
w=self.tree.get_object("res352x240")
w.set_label("352x"+res1)
def set_widgets(self):
""" sets the widgets to the values specificated in SELF.FILE_PROPERTIES """
dsize,minvid,maxvid=devede_other.get_dvd_size(None,self.disctocreate)
if self.disctocreate=="vcd":
w=self.tree.get_object("video_rate_adj")
w.set_value(1152)
w=self.tree.get_object("audio_rate_adj")
w.set_value(224)
elif (self.disctocreate=="svcd") or (self.disctocreate=="cvd"):
w=self.tree.get_object("audio_rate_adj")
w.set_lower(64)
w.set_upper(384)
#w.set_range(64,384)
else:
print "entro en parte critica"
w=self.tree.get_object("audio_rate_adj")
print "paso por set_lower"
w.set_lower(128)
w.set_upper(448)
#w.set_range(128,448)
if self.disctocreate!="vcd":
w=self.tree.get_object("video_rate_adj")
w.set_lower(minvid)
w.set_upper(maxvid)
#w.set_range(minvid,maxvid)
if self.file_properties==None:
return
w=self.tree.get_object("force_subs")
w.set_active(self.file_properties["force_subs"])
w1=self.tree.get_object("aspect_ratio_4_3")
w2=self.tree.get_object("aspect_ratio_16_9")
w1.set_active(True)
print "Activo ASPECT_RATIO"
print self.disctocreate
if (self.disctocreate=="dvd") or (self.disctocreate=="divx"):
w1.set_sensitive(True)
w2.set_sensitive(True)
if self.file_properties["aspect"]>1.6:
w2.set_active(True)
else:
w1.set_active(True)
else:
w1.set_sensitive(False)
w2.set_sensitive(False)
if self.file_properties["resolution"]==0: # auto resolution
w=self.tree.get_object("resauto")
elif self.file_properties["resolution"]==1: # 720x480
w=self.tree.get_object("res720x480")
elif self.file_properties["resolution"]==2: # 704x480
w=self.tree.get_object("res704x480")
elif self.file_properties["resolution"]==3: # 480x480
w=self.tree.get_object("res480x480")
elif self.file_properties["resolution"]==4: # 352x480
w=self.tree.get_object("res352x480")
elif self.file_properties["resolution"]==6: # 1280x720
w=self.tree.get_object("res1280x720")
elif self.file_properties["resolution"]==7: # 1920x1080
w=self.tree.get_object("res1920x1080")
elif self.file_properties["resolution"]==8: # 160x128
w=self.tree.get_object("res160x128")
else:
w=self.tree.get_object("res352x240")
w.set_active(True)
w=self.tree.get_object("trell")
w.set_active(self.file_properties["trellis"])
w=self.tree.get_object("twopass")
w.set_active(self.file_properties["twopass"])
w=self.tree.get_object("turbo1stpass")
w.set_active(self.file_properties["turbo1stpass"])
w.set_sensitive(self.file_properties["twopass"])
if self.file_properties["mbd"]==0:
w=self.tree.get_object("mbd")
elif self.file_properties["mbd"]==1:
w=self.tree.get_object("mbd1")
else:
w=self.tree.get_object("mbd2")
w.set_active(True)
if self.file_properties["deinterlace"]=="none":
w=self.tree.get_object("deinterlace")
else:
w=self.tree.get_object("deinterlace_"+self.file_properties["deinterlace"])
w.set_active(True)
w=self.tree.get_object("volume_adj")
w.set_value(self.file_properties["volume"])
w=self.tree.get_object("ismpeg")
w.set_active(self.file_properties["ismpeg"])
w=self.tree.get_object("copy_audio")
w.set_active(self.file_properties["copy_audio"])
w=self.tree.get_object("isvob")
w.set_active(self.file_properties["isvob"])
w=self.tree.get_object("sound51")
w.set_active(self.file_properties["sound51"])
w=self.tree.get_object("gop12")
w.set_active(self.file_properties["gop12"])
w=self.tree.get_object("subfont_size")
w.set_value(self.file_properties["subfont_size"])
w=self.tree.get_object("sub_fill_color")
color=self.file_properties["sub_fill_color"]
gdk_color=gtk.gdk.Color(color[0],color[1],color[2])
w.set_color(gdk_color)
w.set_alpha(color[3])
w=self.tree.get_object("sub_outline_color")
color=self.file_properties["sub_outline_color"]
gdk_color=gtk.gdk.Color(color[0],color[1],color[2])
w.set_color(gdk_color)
w.set_alpha(color[3])
w=self.tree.get_object("swap_fields")
w.set_active(self.file_properties["swap_fields"])
w=self.tree.get_object("custom_params")
w.set_text(self.file_properties["params"])
w=self.tree.get_object("custom_params_lavcopts")
w.set_text(self.file_properties["params_lavc"])
w=self.tree.get_object("custom_params_vf")
w.set_text(self.file_properties["params_vf"])
if (self.disctocreate=="divx"):
w=self.tree.get_object("custom_params_lameopts")
w.set_text(self.file_properties["params_lame"])
vrate=self.tree.get_object("video_rate")
vrate.set_value(self.file_properties["vrate"])
arate=self.tree.get_object("audio_rate")
arate.set_value(self.file_properties["arate"])
w=self.tree.get_object("audiodelay")
w.set_value(self.file_properties["adelay"])
if self.file_properties["blackbars"]==0:
w=self.tree.get_object("blackbars")
else:
w=self.tree.get_object("scalepict")
w.set_active(True)
w=self.tree.get_object("do_chapters")
if self.file_properties["lchapters"]==0:
w.set_active(False)
w=self.tree.get_object("chapter_long")
w.set_sensitive(False)
else:
w.set_active(True)
w=self.tree.get_object("chapter_long")
w.set_sensitive(True)
w.set_value(self.file_properties["lchapters"])
if self.file_properties["fps"]==25:
w=self.tree.get_object("video_pal")
else:
w=self.tree.get_object("video_ntsc")
w.set_active(True)
if self.file_properties["cutting"]==0:
w=self.tree.get_object("full_length")
elif self.file_properties["cutting"]==1:
w=self.tree.get_object("first_half")
else:
w=self.tree.get_object("second_half")
w.set_active(True)
print "Rotate: "+str(self.file_properties["rotate"])
if self.file_properties["rotate"]==0:
w=self.tree.get_object("rotation0")
elif self.file_properties["rotate"]==90:
w=self.tree.get_object("rotation90")
elif self.file_properties["rotate"]==180:
w=self.tree.get_object("rotation180")
elif self.file_properties["rotate"]==270:
w=self.tree.get_object("rotation270")
w.set_active(True)
w=self.tree.get_object("hmirror")
w.set_active(self.file_properties["hmirror"])
w=self.tree.get_object("vmirror")
w.set_active(self.file_properties["vmirror"])
self.audio_model.clear()
if len(self.file_properties["audio_list"])>0:
w=self.tree.get_object("hasaudiotracks")
w.show()
w=self.tree.get_object("noaudiotracks")
w.hide()
position=0
for track in self.file_properties["audio_list"]:
print "Meto pista "+str(track)
iterator=self.audio_model.insert(position)
self.audio_model.set_value(iterator,0,track)
position+=1
print "Pista seleccionada: "+str(self.file_properties["audio_stream"])
w=self.tree.get_object("audiotrack")
w.set_active(self.file_properties["audio_list"].index(self.file_properties["audio_stream"]))
else:
w=self.tree.get_object("hasaudiotracks")
w.hide()
w=self.tree.get_object("noaudiotracks")
w.show()
self.refresh_subtitles()
if ((self.global_vars["encoder_video"]=="ffmpeg") or (self.global_vars["encoder_video"]=="avconv")):
use_ffmpeg=False
else:
use_ffmpeg=True
self.tree.get_object("turbo1stpass").set_visible(use_ffmpeg)
self.tree.get_object("deinterlace_md").set_visible(use_ffmpeg)
self.tree.get_object("deinterlace_l5").set_visible(use_ffmpeg)
self.tree.get_object("deinterlace_lb").set_visible(use_ffmpeg)
self.tree.get_object("lavcopts_label").set_visible(use_ffmpeg)
self.tree.get_object("lameopts_label").set_visible(use_ffmpeg)
self.tree.get_object("custom_params_lavcopts").set_visible(use_ffmpeg)
self.tree.get_object("custom_params_lameopts").set_visible(use_ffmpeg)
#self.tree.get_object("volume_frame").set_visible(use_ffmpeg)
self.tree.get_object("audiotrack_box").set_visible(use_ffmpeg)
self.tree.get_object("frame_field_order").set_visible(use_ffmpeg)
def refresh_subtitles(self):
self.sub_model.clear()
position=0
for subtitle in self.file_properties["sub_list"]:
iterator=self.sub_model.insert(position)
self.sub_model.set_value(iterator,0,position)
name=subtitle["subtitles"]
while True:
pos=name.find(os.sep)
if (pos==-1):
break
name=name[pos+1:]
self.sub_model.set_value(iterator,1,name)
self.sub_model.set_value(iterator,2,subtitle["sub_codepage"])
self.sub_model.set_value(iterator,3,subtitle["sub_language"])
position+=1
w=self.tree.get_object("sub_treeview")
w.get_selection().select_path(0)
self.set_film_buttons()
def set_film_buttons(self):
""" Enables or disables all the buttons, based in the current disk type and other widgets """
w1=self.tree.get_object("fileaccept")
w=self.tree.get_object("moviefile")
cfile=w.get_filename()
w=self.tree.get_object("preview_film")
if (cfile=="") or (cfile==None):
w.set_sensitive(False)
w1.set_sensitive(False)
else:
w.set_sensitive(True)
w1.set_sensitive(True)
w0=self.tree.get_object("ismpeg")
w0s=w0.get_active()
if w0s:
grupo2=False
else:
grupo2=True
w1=self.tree.get_object("copy_audio")
w1s=w1.get_active()
if w1s:
copy_audio=False
else:
copy_audio=grupo2
w2=self.tree.get_object("isvob")
w2s=w2.get_active()
if w2s:
isvob=False
else:
isvob=grupo2
if (self.disctocreate!="dvd") and (self.disctocreate!="divx"):
w1.set_active(False)
w1.set_sensitive(False)
sound51=False
else:
w1.set_sensitive(grupo2)
sound51=grupo2
if w0s:
w2.set_sensitive(False)
w1.set_sensitive(False)
else:
w2.set_sensitive(True)
w1.set_sensitive(True)
if w1s:
w2.set_sensitive(False)
else:
w2.set_sensitive(True)
if w2s:
w0.set_sensitive(False)
w1.set_sensitive(False)
else:
w1.set_sensitive(True)
w0.set_sensitive(True)
if self.disctocreate =="vcd":
grupo1=False
else:
grupo1=grupo2
if (self.disctocreate=="dvd") or (self.disctocreate=="divx"):
w=self.tree.get_object("sound51")
if w.get_active():
w=self.tree.get_object("audio_rate_adj")
w.set_lower(384)
w.set_upper(448)
if w.get_value()<384:
w.set_value(384)
#w.set_range(384,448)
else:
w=self.tree.get_object("audio_rate_adj")
w.set_lower(128)
w.set_upper(448)
#w.set_range(128,448)
grupo3=grupo2
try:
if self.file_properties["olength"]<60:
grupo3=False
except:
grupo3=False
w=self.tree.get_object("video_rate")
w.set_sensitive(grupo1 and isvob)
w=self.tree.get_object("audio_rate")
w.set_sensitive(grupo1 and copy_audio and isvob)
w=self.tree.get_object("swap_fields")
w.set_sensitive(grupo1 and isvob)
w=self.tree.get_object("gop12")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("volume_scale")
w.set_sensitive(grupo2 and isvob and copy_audio)
w=self.tree.get_object("volume_level")
w.set_sensitive(grupo2 and isvob and copy_audio)
w=self.tree.get_object("reset_volume")
w.set_sensitive(grupo2 and isvob and copy_audio)
w=self.tree.get_object("sound51")
if grupo1==False:
w.set_active(False)
w.set_sensitive(sound51)
w=self.tree.get_object("resauto")
w.set_sensitive(grupo1 and isvob)
if (w.get_active()) and (self.disctocreate=="divx"):
set_aspect=False
else:
set_aspect=True
w=self.tree.get_object("res352x240")
w.set_sensitive(grupo1 and isvob)
w=self.tree.get_object("res352x480")
w.set_sensitive(grupo1 and isvob)
w=self.tree.get_object("res480x480")
w.set_sensitive(grupo1 and isvob)
w=self.tree.get_object("res704x480")
w.set_sensitive(grupo1 and isvob)
w=self.tree.get_object("res720x480")
w.set_sensitive(grupo1 and isvob)
w=self.tree.get_object("full_length")
w.set_sensitive(grupo3)
w=self.tree.get_object("first_half")
w.set_sensitive(grupo3)
w=self.tree.get_object("second_half")
w.set_sensitive(grupo3)
w=self.tree.get_object("video_pal")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("video_ntsc")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("audiodelay")
w.set_sensitive(copy_audio and isvob)
w=self.tree.get_object("blackbars")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("scalepict")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("custom_params")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("custom_params_vf")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("custom_params_lavcopts")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("custom_params_lameopts")
w.set_sensitive(copy_audio and isvob)
w2=self.tree.get_object("lameopts_label")
if self.disctocreate=="divx":
w.show()
w2.show()
else:
w.hide()
w2.hide()
w=self.tree.get_object("trell")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("rotation0")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("rotation90")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("rotation180")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("rotation270")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("hmirror")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("vmirror")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("mbd")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("mbd1")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("mbd2")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("twopass")
w.set_sensitive(grupo2 and isvob)
tp = w.get_active()
w=self.tree.get_object("turbo1stpass")
w.set_sensitive(grupo2 and isvob and tp)
w=self.tree.get_object("deinterlace")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("deinterlace_lb")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("deinterlace_md")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("deinterlace_fd")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("deinterlace_l5")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("deinterlace_yadif")
w.set_sensitive(grupo2 and isvob)
w=self.tree.get_object("audiotrack")
w.set_sensitive(grupo2)
w1=self.tree.get_object("aspect_ratio_4_3")
w2=self.tree.get_object("aspect_ratio_16_9")
if (self.disctocreate == "dvd") or (self.disctocreate == "divx"):
w1.set_sensitive(grupo2 and isvob and set_aspect)
w2.set_sensitive(grupo2 and isvob and set_aspect)
else:
w1.set_sensitive(False)
w2.set_sensitive(False)
w1=self.tree.get_object("sub_remove")
w2=self.tree.get_object("sub_add")
try:
sub_number=len(self.file_properties["sub_list"])
if sub_number==0:
w1.set_sensitive(False)
else:
w1.set_sensitive(True)
if sub_number>=32:
w2.set_sensitive(False)
else:
w2.set_sensitive(True)
except:
w1.set_sensitive(False)
w2.set_sensitive(False)
def set_global_values(self):
""" Repaints all the data about the current film, recalculating
the size needed and other params """
if self.file_properties==None:
empty=True
else:
empty=False
w=self.tree.get_object("o_size2")
if empty:
w.set_text("")
else:
w.set_text(str(self.file_properties["owidth"])+"x"+str(self.file_properties["oheight"]))
w=self.tree.get_object("leng2")
if empty:
w.set_text("")
else:
w.set_text(str(self.file_properties["olength"]))
w=self.tree.get_object("fps")
if empty:
w.set_text("")
else:
w.set_text(str(self.file_properties["ofps"]))
w=self.tree.get_object("vrate2")
if empty:
w.set_text("")
else:
w.set_text(str(self.file_properties["ovrate"]))
w=self.tree.get_object("arate2")
if empty:
w.set_text("")
else:
w.set_text(str(self.file_properties["oarate"]))
w=self.tree.get_object("video_rate")
vrate=w.get_value()
w=self.tree.get_object("audio_rate")
arate=w.get_value()
w=self.tree.get_object("full_length")
if w.get_active():
divide=False
divide2=0
else:
divide=True
divide2=1
w=self.tree.get_object("eleng2")
if empty:
w.set_text("")
else:
w2=self.tree.get_object("ismpeg")
w4=self.tree.get_object("isvob")
props={}
props["ofps"]=self.file_properties["ofps"]
props["ofps2"]=self.file_properties["ofps2"]
w3=self.tree.get_object("video_pal")
if w3.get_active():
props["fps"]=25
else:
props["fps"]=30
w3=self.tree.get_object("copy_audio")
props["copy_audio"]=w3.get_active()
w3=self.tree.get_object("ismpeg")
props["ismpeg"]=w3.get_active()
print "Props: "+str(props)
speed1,speed2=devede_other.get_speedup(props)
l=devede_other.calcula_tamano_parcial(vrate,arate,self.file_properties["filesize"],self.file_properties["olength"],len(self.file_properties["sub_list"]),w2.get_active(),w4.get_active(),divide2,speed1,speed2)
#if w2.get_active():
# l=int(self.file_properties["filesize"]/1000000)
#else:
# l=int(((vrate+arate)*self.file_properties["olength"])/8000)
# if divide:
# l/=2
#l+=int((8.0*float(len(self.file_properties["sub_list"]))*self.file_properties["olength"])/8000.0)
w.set_text(str(int(l/1000)))
w=self.tree.get_object("f_size2")
if empty:
w.set_text("")
else:
w.set_text(str(self.file_properties["width"])+"x"+str(self.file_properties["height"]))
class ask_subtitle:
def __init__(self,gladefile,filepath,gvars,filename=None):
self.global_vars=gvars
self.gladefile=gladefile
self.tree=devede_other.create_tree(self,"add_subtitle2",self.gladefile)
self.lang_list=[]
self.cpage_list=[]
pos=0
self.lang=-1
self.asciie=-1
self.utf8e=-1
self.utf16e=-1
self.isoe=-1
languages=open(os.path.join(self.gladefile,"languages.lst"),"r")
w=self.tree.get_object("sub_language")
for element in languages:
if element[:-1]==self.global_vars["sub_language"]:
self.lang=pos
w.append_text(element[:-1])
self.lang_list.append(element[:-1])
pos+=1
languages.close()
w.set_active(self.lang)
pos=0
self.chelement=0
codepages=open(os.path.join(self.gladefile,"codepages.lst"),"r")
w=self.tree.get_object("sub_codepage")
for element in codepages:
if element[:-1]=="ASCII":
self.asciie=pos
if element[:-1]=="UTF-8":
self.utf8e=pos
if element[:-1]=="UTF-16":
self.utf16e=pos
if element[:-1]=="ISO-8859-1":
self.isoe=pos
if element[:-1]==self.global_vars["sub_codepage"]:
self.chelement=pos
w.append_text(element[:-1])
self.cpage_list.append(element[:-1])
pos+=1
codepages.close()
if self.chelement!=-1:
w.set_active(self.chelement)
elif (self.utf8e!=-1):
w.set_active(self.utf8e)
else:
w.set_active(self.isoe)
self.window=self.tree.get_object("add_subtitle")
if (filepath!=""):
w=self.tree.get_object("subtitles_chooser")
w.set_current_folder(filepath)
if (filename!=None) and (filename!=""):
self.tree.get_object("subtitles_chooser").set_filename(filename)
self.window.show()
self.set_status()
def on_clear_subtitles_clicked(self,widget):
file=self.tree.get_object("subtitles_chooser")
file.unselect_all()
def on_subtitles_chooser_selection_changed(self,widget):
filename=widget.get_filename()
if (filename!="") and (filename!=None):
w=self.tree.get_object("sub_codepage")
autotype=devede_other.check_utf().do_check(filename)
print "Subtitles changed to type: "+str(autotype)
if autotype=="ascii":
w.set_active(self.asciie)
self.autotype="ASCII"
elif autotype=="utf8":
w.set_active(self.utf8e)
self.autotype="UTF-8"
elif autotype=="utf16":
w.set_active(self.utf16e)
self.autotype="UTF-16"
elif self.chelement!=-1:
w.set_active(self.chelement)
self.autotype=""
else:
w.set_active(self.isoe)
self.autotype=""
self.set_status()
def set_status(self):
filename=self.tree.get_object("subtitles_chooser").get_filename()
if (filename=="") or (filename==None):
status=False
else:
status=True
w=self.tree.get_object("sub_accept")
w.set_sensitive(status)
def run(self):
ret=self.window.run()
if ret==-5: # OK
ret_val={}
w=self.tree.get_object("subtitles_chooser")
ret_val["subtitles"]=w.get_filename()
w=self.tree.get_object("sub_codepage")
ret_val["sub_codepage"]=self.cpage_list[w.get_active()]
if (ret_val["sub_codepage"]!=self.autotype) and (ret_val["sub_codepage"][:3]!="UTF"):
self.global_vars["sub_codepage"]=ret_val["sub_codepage"]
w=self.tree.get_object("sub_language")
ret_val["sub_language"]=self.lang_list[w.get_active()]
self.global_vars["sub_language"]=ret_val["sub_language"]
w=self.tree.get_object("sub_up")
ret_val["subtitles_up"]=w.get_active()
else:
ret_val=None
self.window.hide()
self.window.destroy()
self.window=None
return(ret_val)