Python VideoClip.__init__方法代码示例

# 需要导入模块: from moviepy.video.VideoClip import VideoClip [as 别名]
# 或者: from moviepy.video.VideoClip.VideoClip import __init__ [as 别名]
 def __init__(self, filename, ismask=False, has_mask=False,
              audio=True, audio_buffersize = 200000,
              audio_fps=44100, audio_nbytes=2, verbose=False):
     
     VideoClip.__init__(self, ismask)
     
     # We store the construction parameters in case we need to make
     # a copy (a 'co-reader').
     
     self.parameters = {'filename':filename, 'ismask':ismask,
                        'has_mask':has_mask, 'audio':audio,
                        'audio_buffersize':audio_buffersize}
     
     # Make a reader
     pix_fmt= "rgba" if has_mask else "rgb24"
     self.reader = FFMPEG_VideoReader(filename, pix_fmt=pix_fmt)
     
     # Make some of the reader's attributes accessible from the clip
     self.duration = self.reader.duration
     self.fps = self.reader.fps
     self.size = self.reader.size
     self.get_frame = lambda t: self.reader.get_frame(t)
     
     # Make a reader for the audio, if any.
     if audio:
         try:
             self.audio = AudioFileClip(filename, buffersize= audio_buffersize,
                 fps = audio_fps, nbytes = audio_nbytes)
         except:
             if verbose:
                 print "No audio found in %s"%filename
             pass

# 需要导入模块: from moviepy.video.VideoClip import VideoClip [as 别名]
# 或者: from moviepy.video.VideoClip.VideoClip import __init__ [as 别名]
    def __init__(self, filename, has_mask=False,
                 audio=True, audio_buffersize = 200000,
                 audio_fps=44100, audio_nbytes=2, verbose=False):
        
        VideoClip.__init__(self)
        
        # Make a reader
        pix_fmt= "rgba" if has_mask else "rgb24"
        self.reader = FFMPEG_VideoReader(filename, pix_fmt=pix_fmt)
        
        # Make some of the reader's attributes accessible from the clip
        self.duration = self.reader.duration
        self.end = self.reader.duration
        
        self.fps = self.reader.fps
        self.size = self.reader.size

        if has_mask:

          self.get_frame = lambda t: self.reader.get_frame(t)[:,:,:3]
          mask_gf =  lambda t: self.reader.get_frame(t)[:,:,3]/255.0
          self.mask = (VideoClip(ismask = True, get_frame = mask_gf)
                       .set_duration(self.duration))
          self.mask.fps = self.fps

        else:

          self.get_frame = lambda t: self.reader.get_frame(t)
        
        # Make a reader for the audio, if any.
        if audio and self.reader.infos['audio_found']:
            self.audio = AudioFileClip(filename,
                                       buffersize= audio_buffersize,
                                       fps = audio_fps,
                                       nbytes = audio_nbytes)

# 需要导入模块: from moviepy.video.VideoClip import VideoClip [as 别名]
# 或者: from moviepy.video.VideoClip.VideoClip import __init__ [as 别名]
    def __init__(self, foldername, fps, withmask=True, ismask=False):

        VideoClip.__init__(self, ismask=ismask)

        self.directory = foldername
        self.fps = fps
        self.imagefiles = sorted(os.listdir(foldername))

        self.duration = 1.0 * len(self.imagefiles) / self.fps
        self.end = self.duration

        self.lastpos = None
        self.lastimage = None

        def get_frame(t):

            pos = int(self.fps * t)
            if pos != self.lastpos:
                self.lastimage = ffmpeg_read_image(self.imagefiles[ind], withmask=withmask)
                self.lastpos = pos

            return self.lastimage

        self.get_frame = get_frame
        self.size = get_frame(0).shape[:2][::-1]

# 需要导入模块: from moviepy.video.VideoClip import VideoClip [as 别名]
# 或者: from moviepy.video.VideoClip.VideoClip import __init__ [as 别名]
    def __init__(self, glob_store, freq, fft_clip, ismask=False):

        def make_frame(t):
            freq_amplitude = fft_clip.freq_amplitude(freq, t)
            image_data = glob_store.image_from_normal(freq_amplitude)
            return image_data

        VideoClip.__init__(self, make_frame=make_frame, ismask=ismask, duration=fft_clip.duration)

# 需要导入模块: from moviepy.video.VideoClip import VideoClip [as 别名]
# 或者: from moviepy.video.VideoClip.VideoClip import __init__ [as 别名]
    def __init__(self, subtitles, make_textclip=None):
        
        VideoClip.__init__(self, has_constant_size=False)

        if isinstance( subtitles, basestring):
            subtitles = file_to_subtitles(subtitles)

        subtitles = [(map(cvsecs, tt),txt) for tt, txt in subtitles]
        self.subtitles = subtitles
        self.textclips = dict()

        if make_textclip is None:

            make_textclip = lambda txt: TextClip(txt, font='Georgia-Bold',
                                        fontsize=24, color='white',
                                        stroke_color='black', stroke_width=0.5)

        self.make_textclip = make_textclip
        self.start=0
        self.duration = max([tb for ((ta,tb), txt) in self.subtitles])
        self.end=self.duration
        
        def add_textclip_if_none(t):
            """ Will generate a textclip if it hasn't been generated asked
            to generate it yet. If there is no subtitle to show at t, return
            false. """
            sub =[((ta,tb),txt) for ((ta,tb),txt) in self.textclips.keys()
                   if (ta<=t<tb)]
            if sub == []:
                sub = [((ta,tb),txt) for ((ta,tb),txt) in self.subtitles if
                       (ta<=t<tb)]
                if sub == []:
                    return False
            sub = sub[0]
            if sub not in self.textclips.keys():
                self.textclips[sub] = self.make_textclip(sub[1])

            return sub

        def make_frame(t):
            sub = add_textclip_if_none(t)
            return (self.textclips[sub].get_frame(t) if sub
                    else np.array([[[0,0,0]]]))

        def make_mask_frame(t):
            sub = add_textclip_if_none(t)
            return (self.textclips[sub].mask.get_frame(t) if sub
                    else np.array([[0]]))
        
        self.make_frame = make_frame
        hasmask = (self.make_textclip('T').mask is not None)
        self.mask = (VideoClip(make_mask_frame, ismask=True) if hasmask else None)

# 需要导入模块: from moviepy.video.VideoClip import VideoClip [as 别名]
# 或者: from moviepy.video.VideoClip.VideoClip import __init__ [as 别名]
    def __init__(self, clips, size=None, bg_color=None, transparent=False,
                 ismask=False):
                     
        if size is None:
            size = clips[0].size
        
        if bg_color is None:
            bg_color = 0.0 if ismask else (0, 0, 0)
        
        VideoClip.__init__(self)
        
        self.size = size
        self.ismask = ismask
        self.clips = clips
        self.transparent = transparent
        self.bg_color = bg_color
        self.bg = ColorClip(size, col=self.bg_color).get_frame(0)
        
        # compute duration
        ends = [c.end for c in self.clips]
        if not any([(e is None) for e in ends]):
            self.duration = max(ends)
            self.end = max(ends)

        # compute audio
        audioclips = [v.audio for v in self.clips if v.audio != None]
        if len(audioclips) > 0:
            self.audio = CompositeAudioClip(audioclips)

        # compute mask
        if transparent:
            maskclips = [c.mask.set_pos(c.pos) for c in self.clips
                         if c.mask is not None]
            if maskclips != []:
                self.mask = CompositeVideoClip(maskclips,self.size,
                                        transparent=False, ismask=True)

        def gf(t):
            """ The clips playing at time `t` are blitted over one
                another. """

            f = self.bg
            for c in self.playing_clips(t):
                    f = c.blit_on(f, t)
            return f

        self.get_frame = gf

# 需要导入模块: from moviepy.video.VideoClip import VideoClip [as 别名]
# 或者: from moviepy.video.VideoClip.VideoClip import __init__ [as 别名]
    def __init__(self, subtitles, make_textclip=None):
        
        VideoClip.__init__(self)

        if isinstance( subtitles, str):
            subtitles = file_to_subtitles(subtitles)

        subtitles = [(map(cvsecs, tt),txt) for tt, txt in subtitles]
        self.subtitles = subtitles
        self.textclips = dict()

        if make_textclip is None:

            make_textclip = lambda txt: TextClip(txt, font='Georgia-Bold',
                                        fontsize=24, color='white',
                                        stroke_color='black', stroke_width=0.5)

        self.make_textclip = make_textclip
        self.start=0
        self.duration = max([tb for ((ta,tb), txt) in self.subtitles])
        self.end=self.duration
        
        def add_textclip_if_none(t):
            sub =[((ta,tb),txt) for ((ta,tb),txt) in self.textclips.keys()
                   if (ta<=t<tb)]
            if sub == []:
                sub = [((ta,tb),txt) for ((ta,tb),txt) in self.subtitles if
                       (ta<=t<tb)]
                if sub == []:
                    return False
            sub = sub[0]
            if sub not in self.textclips.keys():
                self.textclips[sub] = self.make_textclip(sub[1])
            return sub

        def get_frame(t):
            sub = add_textclip_if_none(t)
            return (self.textclips[sub].get_frame(t) if sub
                    else np.array([[[0,0,0]]]))

        def mask_get_frame(t):
            sub = add_textclip_if_none(t)
            return (self.textclips[sub].mask.get_frame(t) if sub
                    else np.array([[0]]))
        
        self.get_frame = get_frame
        self.mask = VideoClip(ismask=True, get_frame=mask_get_frame)

# 需要导入模块: from moviepy.video.VideoClip import VideoClip [as 别名]
# 或者: from moviepy.video.VideoClip.VideoClip import __init__ [as 别名]
    def __init__(self, filename, has_mask=False,
                 audio=True, audio_buffersize = 200000,
                 target_resolution=None, resize_algorithm='bicubic',
                 audio_fps=44100, audio_nbytes=2, verbose=False,
                 fps_source='tbr'):

        VideoClip.__init__(self)

        # Make a reader
        pix_fmt= "rgba" if has_mask else "rgb24"
        self.reader = None # need this just in case FFMPEG has issues (__del__ complains)
        self.reader = FFMPEG_VideoReader(filename, pix_fmt=pix_fmt,
                                         target_resolution=target_resolution,
                                         resize_algo=resize_algorithm,
                                         fps_source=fps_source)

        # Make some of the reader's attributes accessible from the clip
        self.duration = self.reader.duration
        self.end = self.reader.duration

        self.fps = self.reader.fps
        self.size = self.reader.size
        self.rotation = self.reader.rotation

        self.filename = self.reader.filename

        if has_mask:

            self.make_frame = lambda t: self.reader.get_frame(t)[:,:,:3]
            mask_mf =  lambda t: self.reader.get_frame(t)[:,:,3]/255.0
            self.mask = (VideoClip(ismask = True, make_frame = mask_mf)
                       .set_duration(self.duration))
            self.mask.fps = self.fps

        else:

            self.make_frame = lambda t: self.reader.get_frame(t)

        # Make a reader for the audio, if any.
        if audio and self.reader.infos['audio_found']:

            self.audio = AudioFileClip(filename,
                                       buffersize= audio_buffersize,
                                       fps = audio_fps,
                                       nbytes = audio_nbytes)

# 需要导入模块: from moviepy.video.VideoClip import VideoClip [as 别名]
# 或者: from moviepy.video.VideoClip.VideoClip import __init__ [as 别名]
    def __init__(self, foldername, fps, transparent=True, ismask=False):

        VideoClip.__init__(self, ismask=ismask)

        self.directory = foldername
        self.fps = fps
        allfiles = os.listdir(foldername)
        self.pics = sorted(["%s/%s" % (foldername, f) for f in allfiles
                            if not f.endswith(('.txt','.wav'))])
        
        audio = [f for f in allfiles if f.endswith('.wav')]
        
        if len(audio) > 0:
            self.audio = AudioFileClip(audio[0])
            self.audiofile =audio[0]

        self.size = imread(self.pics[0]).shape[:2][::-1]

        if imread(self.pics[0]).shape[2] == 4:  # transparent png

            if ismask:
                def get_frame(t):
                    return 1.0 * imread(self.pics[int(self.fps * t)])[:, :, 3] / 255
            else:
                def get_frame(t):
                    return imread(self.pics[int(self.fps * t)])[:, :, :2]

            if transparent:
                self.mask = DirectoryClip(foldername, fps, ismask=True)

        else:

            def get_frame(t):
                return imread(self.pics[int(self.fps * t)])

        self.get_frame = get_frame
        self.duration = 1.0 * len(self.pics) / self.fps

# 需要导入模块: from moviepy.video.VideoClip import VideoClip [as 别名]
# 或者: from moviepy.video.VideoClip.VideoClip import __init__ [as 别名]
 def __init__(self, filename, ismask=False, has_mask=False,
              audio=True, audio_buffersize = 200000,
              audio_fps=44100, audio_nbytes=2, verbose=False):
     
     VideoClip.__init__(self, ismask)
     
     # Make a reader
     pix_fmt= "rgba" if has_mask else "rgb24"
     self.reader = FFMPEG_VideoReader(filename, pix_fmt=pix_fmt,print_infos=verbose)
     
     # Make some of the reader's attributes accessible from the clip
     self.duration = self.reader.duration
     self.end = self.reader.duration
     
     self.fps = self.reader.fps
     self.size = self.reader.size
     self.get_frame = lambda t: self.reader.get_frame(t)
     
     # Make a reader for the audio, if any.
     if audio:
         self.audio = AudioFileClip(filename,
                                    buffersize= audio_buffersize,
                                    fps = audio_fps,
                                    nbytes = audio_nbytes)

# 需要导入模块: from moviepy.video.VideoClip import VideoClip [as 别名]
# 或者: from moviepy.video.VideoClip.VideoClip import __init__ [as 别名]
    def __init__(self, clips, size=None, bg_color=None, use_bgclip=False,
                 ismask=False):

        if size is None:
            size = clips[0].size

        
        if use_bgclip and (clips[0].mask is None):
            transparent = False
        else:
            transparent = (bg_color is None)
        
        if bg_color is None:
            bg_color = 0.0 if ismask else (0, 0, 0)

        
        fps_list = list(set([c.fps for c in clips if hasattr(c,'fps')]))
        if len(fps_list)==1:
            self.fps= fps_list[0]

        VideoClip.__init__(self)
        
        self.size = size
        self.ismask = ismask
        self.clips = clips
        self.bg_color = bg_color

        if use_bgclip:
            self.bg = clips[0]
            self.clips = clips[1:]
        else:
            self.clips = clips
            self.bg = ColorClip(size, col=self.bg_color)

        
        
        # compute duration
        ends = [c.end for c in self.clips]
        if not any([(e is None) for e in ends]):
            self.duration = max(ends)
            self.end = max(ends)

        # compute audio
        audioclips = [v.audio for v in self.clips if v.audio is not None]
        if len(audioclips) > 0:
            self.audio = CompositeAudioClip(audioclips)

        # compute mask if necessary
        if transparent:
            maskclips = [(c.mask if (c.mask is not None) else
                          c.add_mask().mask).set_pos(c.pos).set_end(c.end).set_start(c.start, change_end=False)
                          for c in self.clips]

            self.mask = CompositeVideoClip(maskclips,self.size, ismask=True,
                                               bg_color=0.0)

        def make_frame(t):
            """ The clips playing at time `t` are blitted over one
                another. """

            f = self.bg.get_frame(t)
            for c in self.playing_clips(t):
                    f = c.blit_on(f, t)
            return f

        self.make_frame = make_frame