U s*^>@s^dZddlmZddlZddlZddlmZddlmZmZm Z m Z m Z m Z GdddZ dS)z This module implements the central object of MoviePy, the Clip, and all the methods that are common to the two subclasses of Clip, VideoClip and AudioClip. )copyN)tqdm)apply_to_audio apply_to_maskconvert_to_secondsoutplacerequires_durationuse_clip_fps_by_defaultc@sVeZdZdZdZddZddZedgdd Zd4d d Z d5ddZ ddZ e e edged6ddZe e edgeddZe e edged7ddZeddZeddZeddZedd Zedgd!d"Zed#d$ge e d8d&d'Ze e ed(d)gd*d+Zeed9d,d-Zd.d/Zd0d1Zd2d3Zd S):Clipa Base class of all clips (VideoClips and AudioClips). Attributes ----------- start: When the clip is included in a composition, time of the composition at which the clip starts playing (in seconds). end: When the clip is included in a composition, time of the composition at which the clip stops playing (in seconds). duration: Duration of the clip (in seconds). Some clips are infinite, in this case their duration will be ``None``. Z TEMP_MPY_cCs(d|_d|_d|_d|_d|_d|_dS)NrF)startenddurationmemoize memoized_tZ memoize_frameselfr\/var/www/html/hiwar_tounsi_level1/my_env_project/lib/python3.8/site-packages/moviepy/Clip.py__init__0s z Clip.__init__cCs8t|}t|drt|j|_t|dr4t|j|_|S)ac Shallow copy of the clip. Returns a shallow copy of the clip whose mask and audio will be shallow copies of the clip's mask and audio if they exist. This method is intensively used to produce new clips every time there is an outplace transformation of the clip (clip.resize, clip.subclip, etc.) audiomask)rhasattrrr)rnewcliprrrr:s     z Clip.copytcCs@|jr2||jkr|jS||}||_||_|Sn ||SdS)z Gets a numpy array representing the RGB picture of the clip at time t or (mono or stereo) value for a sound clip N)rrZmemoized_frame make_frame)rrframerrr get_frameMs  zClip.get_frameNTcs||dkr g}fdd}|s0d|_d|_t|tr@|g}|D]2}t||d}|dk rD|j|d}t|||qD|S)a General processing of a clip. Returns a new Clip whose frames are a transformation (through function ``fun``) of the frames of the current clip. Parameters ----------- fun A function with signature (gf,t -> frame) where ``gf`` will represent the current clip's ``get_frame`` method, i.e. ``gf`` is a function (t->image). Parameter `t` is a time in seconds, `frame` is a picture (=Numpy array) which will be returned by the transformed clip (see examples below). apply_to Can be either ``'mask'``, or ``'audio'``, or ``['mask','audio']``. Specifies if the filter ``fl`` should also be applied to the audio or the mask of the clip, if any. keep_duration Set to True if the transformation does not change the ``duration`` of the clip. Examples -------- In the following ``newclip`` a 100 pixels-high clip whose video content scrolls from the top to the bottom of the frames of ``clip``. >>> fl = lambda gf,t : gf(t)[int(t):int(t)+50, :] >>> newclip = clip.fl(fl, apply_to='mask') Ncs j|SN)rrfunrrrzClip.fl.. keep_duration)set_make_framer r isinstancestrgetattrflsetattr)rr apply_tor$rattraZnew_arrrr)_s%  zClip.flFcs$|dkr g}|jfdd||dS)a Returns a Clip instance playing the content of the current clip but with a modified timeline, time ``t`` being replaced by another time `t_func(t)`. Parameters ----------- t_func: A function ``t-> new_t`` apply_to: Can be either 'mask', or 'audio', or ['mask','audio']. Specifies if the filter ``fl`` should also be applied to the audio or the mask of the clip, if any. keep_duration: ``False`` (default) if the transformation modifies the ``duration`` of the clip. Examples -------- >>> # plays the clip (and its mask and sound) twice faster >>> newclip = clip.fl_time(lambda: 2*t, apply_to=['mask', 'audio']) >>> >>> # plays the clip starting at t=3, and backwards: >>> newclip = clip.fl_time(lambda: 3-t) Ncs ||Srr)Zgfrt_funcrrr!r"zClip.fl_time..r#)r))rr/r+r$rr.rfl_times z Clip.fl_timecOs||f||S)a[ Returns the result of ``func(self, *args, **kwargs)``. for instance >>> newclip = clip.fx(resize, 0.2, method='bilinear') is equivalent to >>> newclip = resize(clip, 0.2, method='bilinear') The motivation of fx is to keep the name of the effect near its parameters, when the effects are chained: >>> from moviepy.video.fx import volumex, resize, mirrorx >>> clip.fx( volumex, 0.5).fx( resize, 0.3).fx( mirrorx ) >>> # Is equivalent, but clearer than >>> resize( volumex( mirrorx( clip ), 0.5), 0.3) r)rfuncargskwargsrrrfxszClip.fxcCs>||_|jdk r"|r"||j|_n|jdk r:|j|j|_dS)a Returns a copy of the clip, with the ``start`` attribute set to ``t``, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. If ``change_end=True`` and the clip has a ``duration`` attribute, the ``end`` atrribute of the clip will be updated to ``start+duration``. If ``change_end=False`` and the clip has a ``end`` attribute, the ``duration`` attribute of the clip will be updated to ``end-start`` These changes are also applied to the ``audio`` and ``mask`` clips of the current clip, if they exist. N)r r r rrZ change_endrrr set_starts  zClip.set_startcCsN||_|jdkrdS|jdkr<|jdk rJtd|tj|_n|j|j|_dS)a0 Returns a copy of the clip, with the ``end`` attribute set to ``t``, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. Also sets the duration of the mask and audio, if any, of the returned clip. Nr)r r r maxr)rrrrrset_ends    z Clip.set_endcCsF||_|r$|dkrdn|j||_n|jdkr6td|j||_dS)a Returns a copy of the clip, with the ``duration`` attribute set to ``t``, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. Also sets the duration of the mask and audio, if any, of the returned clip. If change_end is False, the start attribute of the clip will be modified in function of the duration and the preset end of the clip. Nz1Cannot change clip start when newduration is None)r r r Exceptionr5rrr set_duration s  zClip.set_durationcCs ||_dS)z| Sets a ``make_frame`` attribute for the clip. Useful for setting arbitrary/complicated videoclips. N)r)rrrrrr%'szClip.set_make_framecCs ||_dS)zo Returns a copy of the clip with a new default fps for functions like write_videofile, iterframe, etc. N)fps)rr;rrrset_fps/sz Clip.set_fpscCs ||_dS)z< Says wheter the clip is a mask or not (ismask is a boolean)N)ismask)rr=rrr set_ismask6szClip.set_ismaskcCs ||_dS)z@ Sets wheter the clip should keep the last frame read in memory N)r)rrrrr set_memoize;szClip.set_memoizecCst|tjrn||}}|jdk r6||jkr6dS||jkrDdSd||jk}|jdk rj|||jk9}|S||jko|jdkp||jkSdS)a If t is a time, returns true if t is between the start and the end of the clip. t can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. If t is a numpy array, returns False if none of the t is in theclip, else returns a vector [b_1, b_2, b_3...] where b_i is true iff tti is in the clip. NF)r&npZndarrayminr7r r )rrZtminZtmaxresultrrr is_playing@s    zClip.is_playingt_startt_endrcsdkr|j|jdk r@|jkr@tddd|j|jfddgd}|dkrp|jdk rp|j}n>|dk r|dkr|jdkrtd t|fd n |j|}|dk r||_|j|j|_|S) ad Returns a clip playing the content of the current clip between times ``t_start`` and ``t_end``, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. If ``t_end`` is not provided, it is assumed to be the duration of the clip (potentially infinite). If ``t_end`` is a negative value, it is reset to ``clip.duration + t_end. ``. For instance: :: >>> # cut the last two seconds of the clip: >>> newclip = clip.subclip(0,-2) If ``t_end`` is provided or if the clip has a duration attribute, the duration of the returned clip is set automatically. The ``mask`` and ``audio`` of the resulting subclip will be subclips of ``mask`` and ``audio`` the original clip, if they exist. rNzt_start (%.02f) z"should be smaller than the clip's zduration (%.02f).cs|SrrrrErrr!r"zClip.subclip..)r+z,Error: subclip with negative times (here %s)z5 can only be extracted from clips with a ``duration``)r ValueErrorr0printr'r r )rrErFrrrGrsubclipbs*    z Clip.subcliptatbcs>fdd}||}|jdk r6||jS|SdS)a  Returns a clip playing the content of the current clip but skips the extract between ``ta`` and ``tb``, which can be expressed in seconds (15.35), in (min, sec), in (hour, min, sec), or as a string: '01:03:05.35'. If the original clip has a ``duration`` attribute set, the duration of the returned clip is automatically computed as `` duration - (tb - ta)``. The resulting clip's ``audio`` and ``mask`` will also be cutout if they exist. cs||kSrrrrKrLrrr!r"zClip.cutout..N)r0r r:)rrKrLr)rrrMrcutouts   z Clip.cutoutccslt|}|jtd|jd|dD]@}||}|dk rP|j|krP||}|r`||fVq&|Vq&dS)a Iterates over all the frames of the clip. Returns each frame of the clip as a HxWxN np.array, where N=1 for mask clips and N=3 for RGB clips. This function is not really meant for video editing. It provides an easy way to do frame-by-frame treatment of a video, for fields like science, computer vision... The ``fps`` (frames per second) parameter is optional if the clip already has a ``fps`` attribute. Use dtype="uint8" when using the pictures to write video, images... Examples --------- >>> # prints the maximum of red that is contained >>> # on the first line of each frame of the clip. >>> from moviepy.editor import VideoFileClip >>> myclip = VideoFileClip('myvideo.mp4') >>> print ( [frame[0,:,0].max() for frame in myclip.iter_frames()]) rg?rN) proglogZdefault_bar_loggerZiter_barrAZaranger rdtypeZastype)rr;Z with_timesloggerrPrrrrr iter_framess     zClip.iter_framescCsdS)z= Release any resources that are in use. Nrrrrrcloses z Clip.closecCs|Srrrrrr __enter__szClip.__enter__cCs |dSr)rS)rexc_type exc_value tracebackrrr__exit__sz Clip.__exit__)NT)NF)T)T)rN)NFNN)__name__ __module__ __qualname____doc__Z_TEMP_FILES_PREFIXrrrrr)r0r4rrrr6r8r:r%r<r>r?rDrJrNrr rRrSrTrXrrrrr sd   : %     ! 9 $r )r\rnumpyrArOrZmoviepy.decoratorsrrrrrr r rrrrs