diff --git a/docs/_static/code/getting_started/moviepy_10_minutes/trailer.py b/docs/_static/code/getting_started/moviepy_10_minutes/trailer.py index a914f8950..00adda81f 100644 --- a/docs/_static/code/getting_started/moviepy_10_minutes/trailer.py +++ b/docs/_static/code/getting_started/moviepy_10_minutes/trailer.py @@ -85,7 +85,7 @@ ################ # CLIPS TIMING # ################ -# We have all the clips we need, but if we was to turn all thoses clips into a single one with composition (we will see that during next step) +# We have all the clips we need, but if we was to turn all the clips into a single one with composition (we will see that during next step) # all our clips would start at the same time and play on top of each other, which is obviously not what we want. # To fix that, we need to say when a clip should start and stop in the final clip. # So, lets start by telling when each clip must start and end with appropriate with_* methods @@ -114,7 +114,7 @@ ######################## # CLIPS TIMING PREVIEW # ######################## -# Lets make a first compositing of thoses clips into one single clip and do a quick preview to see if everything is synchro +# Lets make a first compositing of the clips into one single clip and do a quick preview to see if everything is synchro quick_compo = CompositeVideoClip( [ @@ -179,7 +179,7 @@ ################################ # Now that our clip are timed and positionned, lets add some transition to make it more natural # To do so we use the with_effects method and the video effects in vfx -# We call with_effects on our clip and pass him an array of effect objects to apply +# We call with_effects on our clip and pass it an array of effect objects to apply # We'll keep it simple, nothing fancy just cross fading intro_text = intro_text.with_effects([vfx.CrossFadeIn(1), vfx.CrossFadeOut(1)]) logo_clip = logo_clip.with_effects([vfx.CrossFadeIn(1), vfx.CrossFadeOut(1)]) @@ -208,10 +208,10 @@ [vfx.CrossFadeIn(1.5), vfx.FadeOut(1), afx.AudioFadeIn(1.5), afx.AudioFadeOut(1)] ) -# Effects are not only for transition, they can also change a clip timing or apparence +# Effects are not only for transition, they can also change a clip timing or appearance # To show that, lets also modify the Rambo-like part of our clip to be in slow motion -# PS : We do it for effect, but this is one of the few effects that have a direct shortcut, with_speed_scaled -# the others are with_volume_scaled, resized, croped and rotated +# PS: We do it for effect, but this is one of the few effects that have a direct shortcut, with_speed_scaled +# the others are with_volume_scaled, resized, cropped and rotated rambo_clip = rambo_clip.with_effects([vfx.MultiplySpeed(0.5)]) # Because we modified timing of rambo_clip with our MultiplySpeed effect, we must re-assign the following clips timing @@ -247,7 +247,7 @@ # We will start by defining a function that turn a numpy image into sepia # It takes the image as numpy array in entry and return the modified image as output -def sepia_fitler(frame: np.ndarray): +def sepia_filter(frame: np.ndarray): # Sepia filter transformation matrix # Sepia transform works by applying to each pixel of the image the following rules # res_R = (R * .393) + (G *.769) + (B * .189) @@ -277,7 +277,7 @@ def sepia_fitler(frame: np.ndarray): # Now, we simply apply the filter to our clip by calling image_transform, which will call our filter on every frame -rambo_clip = rambo_clip.image_transform(sepia_fitler) +rambo_clip = rambo_clip.image_transform(sepia_filter) # Let's see how our filter look rambo_clip.preview(fps=10) diff --git a/docs/_static/code/user_guide/effects/custom_effect.py b/docs/_static/code/user_guide/effects/custom_effect.py index bfe75a00b..8bde76e99 100644 --- a/docs/_static/code/user_guide/effects/custom_effect.py +++ b/docs/_static/code/user_guide/effects/custom_effect.py @@ -6,7 +6,7 @@ # Here you see a decorator that will verify if our clip have a duration -# MoviePy offer a few of thoses that may come handy when writing your own effects +# MoviePy offer a few of them that may come handy when writing your own effects @requires_duration def progress_bar(clip: VideoClip, color: tuple, height: int = 10): """ diff --git a/docs/_static/code/user_guide/effects/modify_copy_example.py b/docs/_static/code/user_guide/effects/modify_copy_example.py index 6cb001c11..bfde35b74 100644 --- a/docs/_static/code/user_guide/effects/modify_copy_example.py +++ b/docs/_static/code/user_guide/effects/modify_copy_example.py @@ -5,7 +5,7 @@ clip = VideoFileClip("example.mp4") # This does nothing, as multiply_volume will return a copy of clip -# which you will loose immediatly as you dont store it +# which you will loose immediatly as you don't store it # If you was to render clip now, the audio would still be at full volume clip.with_volume_scaled(0.1) diff --git a/docs/_static/code/user_guide/loading/AudioArrayClip.py b/docs/_static/code/user_guide/loading/AudioArrayClip.py index fafc80269..571af157b 100644 --- a/docs/_static/code/user_guide/loading/AudioArrayClip.py +++ b/docs/_static/code/user_guide/loading/AudioArrayClip.py @@ -3,7 +3,7 @@ import numpy as np from moviepy import AudioArrayClip -# We want to play those notes +# We want to play these notes notes = {"A": 440, "B": 494, "C": 523, "D": 587, "E": 659, "F": 698} note_duration = 0.5 diff --git a/docs/_static/code/user_guide/loading/ColorClip.py b/docs/_static/code/user_guide/loading/ColorClip.py index 9c85d962b..b56144211 100644 --- a/docs/_static/code/user_guide/loading/ColorClip.py +++ b/docs/_static/code/user_guide/loading/ColorClip.py @@ -2,5 +2,5 @@ # Color is passed as a RGB tuple myclip = ColorClip(size=(200, 100), color=(255, 0, 0), duration=1) -# We really dont need more than 1 fps do we ? +# We really don't need more than 1 fps do we ? myclip.write_videofile("result.mp4", fps=1) diff --git a/docs/_static/code/user_guide/loading/UpdatedVideoClip.py b/docs/_static/code/user_guide/loading/UpdatedVideoClip.py index c9a7a4920..7959fc36e 100644 --- a/docs/_static/code/user_guide/loading/UpdatedVideoClip.py +++ b/docs/_static/code/user_guide/loading/UpdatedVideoClip.py @@ -39,7 +39,7 @@ def update(self): return # Different face, we increment clip_t and set reset so we will reset on next update. - # We dont reset immediately because we will need current state to make frame + # We don't reset immediately because we will need current state to make frame self.reset = True self.clip_t += 1 / self.fps diff --git a/docs/developer_guide/developers_install.rst b/docs/developer_guide/developers_install.rst index d16d88cb4..0b2520104 100644 --- a/docs/developer_guide/developers_install.rst +++ b/docs/developer_guide/developers_install.rst @@ -4,7 +4,7 @@ Installation for MoviePy developers ====================================== .. warning:: - This part is only destined to people who want to build the MoviePy documentation by themself, or to contribute to MoviePy, normal user dont need it. + This part is only destined to people who want to build the MoviePy documentation by themselves, or to contribute to MoviePy. Normal users don't need it. In addition to MoviePy main libraries, MoviePy developers will also need to install additional libraries to be able to run MoviePy tests and build the MoviePy documentation. @@ -40,7 +40,7 @@ Once libraries installed you can test with: $ python -m pytest -And you can lint with : +And you can lint with: .. code:: bash diff --git a/docs/getting_started/FAQ.rst b/docs/getting_started/FAQ.rst index 56903801e..ffac76e9d 100644 --- a/docs/getting_started/FAQ.rst +++ b/docs/getting_started/FAQ.rst @@ -8,7 +8,7 @@ Common errors that are not bugs These are very common errors which are not considered as bugs to be solved (but you can still ask for this to change). If these answers -don't work for you, please open a bug report on Github_, or on the dedicated forum on Reddit_. +don't work for you, please open a bug report on Github_, or on the dedicated Subreddit_. MoviePy generated a video that cannot be read by my favorite player. @@ -23,7 +23,7 @@ readable only on some readers like VLC. I can't seem to read any video with MoviePy """""""""""""""""""""""""""""""""""""""""""""" -Known reason: you have a deprecated version of FFMPEG, install a recent version from the +Known reason: you have a deprecated version of FFmpeg, install a recent version from the website, not from your OS's repositories! (see :ref:`install`). @@ -33,5 +33,5 @@ Previewing videos make them slower than they are It means that your computer is not good enough to render the clip in real time. Don't hesitate to play with the options of ``preview``: for instance, lower the fps of the sound (11000 Hz is still fine) and the video. Also, downsizing your video with ``resize`` can help. .. _Github: https://github.com/Zulko/moviepy -.. _Reddit: https://www.reddit.com/r/moviepy/ +.. _Subreddit: https://www.reddit.com/r/moviepy/ diff --git a/docs/getting_started/docker.rst b/docs/getting_started/docker.rst index 8b983c20a..50bc6e41c 100644 --- a/docs/getting_started/docker.rst +++ b/docs/getting_started/docker.rst @@ -4,7 +4,7 @@ MoviePy Docker Prerequisites ------------- -Docker installed `Docker for Mac, Docker for windows, linux, etc `_ +Docker installed: `Docker Engine for Linux `_ or `Docker Desktop for Windows/Mac/Linux `_. Build the docker ----------------- diff --git a/docs/getting_started/install.rst b/docs/getting_started/install.rst index 08c83ccd0..99ad09f9a 100644 --- a/docs/getting_started/install.rst +++ b/docs/getting_started/install.rst @@ -3,9 +3,9 @@ Installation ========================== -Installation is done with ``pip`` if you dont have ``pip`` take a look at `how to install it `_. +Installation is done with ``pip``. If you don't have ``pip``, take a look at `how to install it `_. -With ``pip`` installed, just type this in a terminal : +With ``pip`` installed, just type this in a terminal: .. code:: bash @@ -21,14 +21,14 @@ MoviePy depends on the software ffmpeg_ for video reading and writing and on ``f You don't need to worry about ffmpeg_, as it should be automatically downloaded/installed by ImageIO during your first use of MoviePy (it takes a few seconds). -You do need to worry ``ffplay`` if you plan on using video/audio previewing though. In such case, make sure to have ``ffplay`` installed (it can usually be found alongside ``ffmpeg``) and -make sure it is accessible to Python, or look how to set a custom path (see below). +You do need to worry about ``ffplay`` if you plan on using video/audio previewing. For these cases, make sure to have ``ffplay`` installed (it can usually be found alongside ``ffmpeg``) and +make sure it is accessible to Python, or define a custom path (see below). Define custom paths to binaries ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -If you want to use a specific version of FFMPEG and FFPLAY, you can do so using environment variables. +If you want to use a specific version of FFmpeg and FFplay, you can do so using environment variables. There are a couple of environment variables used by MoviePy that allow you to configure custom paths to the external tools. diff --git a/docs/getting_started/moviepy_10_minutes.rst b/docs/getting_started/moviepy_10_minutes.rst index 033a37eb7..6f8e61ecc 100644 --- a/docs/getting_started/moviepy_10_minutes.rst +++ b/docs/getting_started/moviepy_10_minutes.rst @@ -12,7 +12,7 @@ In this tutorial, you will learn the basics of how to use the MoviePy library in
@@ -99,12 +99,12 @@ To do so, we are going to use the ``with_section_cut_out`` method to remove a po :language: python :lines: 41-54 -In that particular case, we have used the ``with_section_cut_out``, but this is only one of the many clip manipulation methods starting with ``with_*``. We will see a few others +In that particular case, we have used the ``with_section_cut_out``, but this is only one of the many clip manipulation methods starting with ``with_``. We will see a few others in this tutorial, but we will miss a lot more. If you want an exhaustive list, go see :ref:`reference_manual`. .. note:: You may have noticed that we have reassigned the ``rodents_clip`` variable instead of just calling a method on it. - This is because in MoviePy, any function starting with ``with_*`` is out-of-place instead of in-place, meaning it does not modify the original data but instead copies it and modifies/returns the copy. + This is because in MoviePy, any function starting with ``with_`` is out-of-place instead of in-place, meaning it does not modify the original data but instead copies it and modifies/returns the copy. So you need to store the result of the method and, if necessary, reassign the original variable to update your clip. @@ -132,19 +132,19 @@ Feel free to experiment with different effects and transitions to achieve the de Step 6: Timing the clips -------------------------- -We have all the clips we need, but if we were to combine all those clips into a single one using composition (we will see that in the next step), all our clips would start at the same time and play on top of each other, which is obviously not what we want. -Also, some video clips, like the images and texts, have no endpoint/duration at creation (except if you have provided a duration parameter), which means trying to render them will throw an error as it would result in an infinite video. +We have all the clips we need, but if we were to combine all the clips into a single one using composition (we will see that in the next step), all our clips would start at the same time and play on top of each other, which is obviously not what we want. +Also, some video clips, like images and texts, have no endpoint/duration at creation (unless you have provided a duration parameter), which means trying to render them will throw an error as it would result in an infinite video. -To fix that, we need to specify when a clip should start and stop in the final clip. So, let's start by indicating when each clip must start and end with the appropriate with_* methods. +To fix that, we need to specify when a clip should start and stop in the final clip. So, let's start by indicating when each clip must start and end using the appropriate with_* methods. .. literalinclude:: /_static/code/getting_started/moviepy_10_minutes/trailer.py :language: python :lines: 85-111 .. note:: - By default, all clips have a start point at ``0``. If a clip has no duration but you set the ``endtime``, then the duration will be calculated for you. The reciprocity is also true. + By default, all clips have a start point at ``0``. If a clip has no ``duration`` but you set the ``end_time``, then the ``duration`` will be calculated for you. The reciprocity is also true. - So in our case, we either use duration or endtime, depending on what is more practical for each specific case. + So in our case, we either use ``duration`` or ``end_time``, depending on what is more practical for each specific case. Step 7: Seeing how all clips combine -------------------------------------- @@ -211,7 +211,7 @@ Well, this looks a lot nicer! For this tutorial, we want to keep things simple, For a more in-depth presentation, see :py:mod:`moviepy.video.fx`, :py:mod:`moviepy.audio.fx`, and :ref:`create_effects`. .. note:: - Looking at the result, you may notice that crossfading makes clips go from transparent to opaque, and reciprocally, and wonder how it works. + Looking at the result, you may notice that cross-fading makes clips go from transparent to opaque, and reciprocally, and wonder how it works. We won't get into details, but know that in MoviePy, you can declare some sections of a video clip to be transparent by using masks. Masks are nothing more than special kinds of video clips that are made of values ranging from ``0`` for a transparent pixel to ``1`` for a fully opaque one. @@ -223,7 +223,7 @@ Step 10: Modifying the appearance of a clip using filters -------------------------------------------------------------- Finally, to make it more epic, we will apply a custom filter to our Rambo clip to make the image sepia. -MoviePy does not come with a sepia effect out of the box, and creating a full custom effect is beyond the scope of this tutorial. However, we will see how we can apply a simple filter to our clip using the ``image_transform`` method. +MoviePy does not come with a sepia effect out of the box, and creating a full custom effect is beyond the scope of this tutorial. However, we will see how we can apply a simple filter to our clip using the :py:meth:`~moviepy.video.VideoClip.VideoClip.image_transform` method. To understand how filters work, you first need to understand that in MoviePy, a clip frame is nothing more than a numpy ``ndarray`` of shape ``HxWx3``. This means we can modify how a frame looks like by applying simple math operations. Doing that on all the frames allows us to apply a filter to our clip! @@ -248,7 +248,7 @@ Step 11: Rendering the final clip to a file So, our final clip is ready, and we have made all the cutting and modifications we want. We are now ready to save the final result into a file. In video editing, this operation is known as rendering. -Again, we will keep things simple and just do video rendering without much tweaking. In most cases, MoviePy and FFMPEG automatically find the best settings. Take a look at the ``write_videofile`` doc for more info. +Again, we will keep things simple and just do video rendering without much tweaking. In most cases, MoviePy and FFmpeg will automatically find the best settings. Take a look at :py:meth:`~moviepy.video.VideoClip.VideoClip.write_videofile` for more info. .. literalinclude:: /_static/code/getting_started/moviepy_10_minutes/trailer.py :language: python diff --git a/docs/getting_started/quick_presentation.rst b/docs/getting_started/quick_presentation.rst index da68f00e2..93ae2a725 100644 --- a/docs/getting_started/quick_presentation.rst +++ b/docs/getting_started/quick_presentation.rst @@ -19,7 +19,7 @@ Here are a few reasons why you may want to edit videos in Python: And here are a few uses for which MoviePy is NOT the best solution: - You only need to do frame-by-frame video analysis (with face detection or other fancy stuff). This could be done with MoviePy in association with other libraries, but really, just use imageio_, OpenCV_ or SimpleCV, these are libraries that specialize in these tasks. -- You only want to convert a video file, or turn a series of image files into a movie. In this case it is better to directly call ``ffmpeg`` (or ``avconv`` or ``mencoder``...) it will be faster more memory-efficient than going through MoviePy. +- You only want to convert a video file, or turn a series of image files into a movie. In this case it is better to directly call ``ffmpeg`` (or ``avconv`` or ``mencoder``...) as it will be faster and more memory-efficient than going through MoviePy. Advantages and limitations @@ -29,9 +29,12 @@ MoviePy has been developed with the following goals in mind: - **Simple and intuitive**. Basic operations can be done in one line. The code is easy to learn and easy to understand for newcomers. - **Flexible**. You have total control over the frames of the video and audio, and creating your own effects is easy as Py. -- **Portable**. The code uses very common software (Numpy and FFMPEG) and can run on (almost) any machine with (almost) any version of Python. +- **Portable**. The code uses very common software (Numpy and FFmpeg) and can run on (almost) any machine with (almost) any version of Python. -For the limitations: MoviePy cannot (yet) stream videos (read from a webcam, or render a video live on a distant machine), and is not really designed for video processing involving many successive frames of a movie (like video stabilization, you'll need another software for that). You can also have memory problems if you use many video, audio, and image sources at the same time (>100), but this will be fixed in future versions. +Limitations: +- MoviePy cannot stream videos (e.g. reading from a webcam, or rendering a video live on a distant machine). +- MoviePy is not really designed for video processing involving many successive frames of a movie (e.g. video stabilization - there is other software better suited for that). +- You can also have memory problems if you use many video, audio, and image sources at the same time (>100). Example code ~~~~~~~~~~~~~~ @@ -57,18 +60,18 @@ Internally, the representation and manipulation of the different media is done u The central concept, the clips ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -The central object of MoviePy is the :py:class:`the clips `, with either :py:class:`~moviepy.audio.AudioClip.AudioClip` for any audio element, or :py:class:`~moviepy.video.VideoClip.VideoClip` for any visual element. Clips really are the base unit of MoviePy, everything you do is with and on them. +The central object of MoviePy is the the :py:class:`Clip `, with either :py:class:`~moviepy.audio.AudioClip.AudioClip` for any audio element, or :py:class:`~moviepy.video.VideoClip.VideoClip` for any visual element. Clips really are the base unit of MoviePy, everything you do is with and on them. -Clips can be created from more than just videos or audios though. They can also be created from an image, a text, a custom animation, a folder of images, and even a simple lambda function ! +Clips can be created from more than just videos or audios though. They can also be created from an image, a text, a custom animation, a folder of images, and even a simple lambda function! -To create your final video, what you will do is essentially : +To create your final video, what you will do is essentially: #. Load different resources as clips (see :ref:`loading`) #. Modify them (see :ref:`modifying`) #. Mixing them into one final clip (see :ref:`compositing`) #. Render them into a file (see :ref:`rendering`) -Of course, MoviePy offer multiple handy solution and tools to facilitate all thoses steps, and let you add new ones by writing your own effects (see :ref:`create_effects`) ! +Of course, MoviePy offer multiple handy solution and tools to facilitate all these steps, and lets you add new ones by writing your own effects (see :ref:`create_effects`)! .. _imageio: https://imageio.github.io/ diff --git a/docs/getting_started/updating_to_v2.rst b/docs/getting_started/updating_to_v2.rst index 92db38411..c32353e7a 100644 --- a/docs/getting_started/updating_to_v2.rst +++ b/docs/getting_started/updating_to_v2.rst @@ -10,20 +10,20 @@ some changes. Dropping support of Python 2 ----------------------------- -Starting with version 2.0 MoviePy **no longer supports Python 2**, which makes sense since Python 2 reached its end of life over three years ago. +Starting with version 2.0, MoviePy **no longer supports Python 2**, since Python 2 reached its end of life in 2020. Focusing on Python 3.7+ allows MoviePy to take advantage of the latest language features and improvements while maintaining code quality and security. Users are encouraged to upgrade to a supported version of Python to continue using MoviePy. -``moviepy.editor`` supression and simplified importation +``moviepy.editor`` suppression and simplified importation --------------------------------------------------------- Before v2.0, it was advised to import from ``moviepy.editor`` whenever you needed to do some sort of manual operations, -such as previewing or hand editing, because the ``editor`` package was in charge of a lot of magic and initialization, making your life +such as previewing or hand editing, because the ``editor`` package handled a lot of magic and initialization, making your life easier, at the cost of initializing some complex modules like ``pygame``. With version 2.0, the ``moviepy.editor`` namespace simply no longer exists. You simply import everything from ``moviepy`` like this: :: - from moviepy import * # Simple and nice, the __all__ is set in moviepy so only usefull things will be loaded + from moviepy import * # Simple and nice, the __all__ is set in moviepy so only useful things will be loaded from moviepy import VideoFileClip # You can also import only the things you really need @@ -74,10 +74,10 @@ If you previously used effect by calling them as clips method, you must now use Dropping many external dependencies and unifying environment ------------------------------------------------------------- -With v1.0, MoviePy relied on many optional external dependencies, trying to gracefully dropback from one library to another in the event one of them was missing, eventually dropping some features when no library was available. +With v1.0, MoviePy relied on many optional external dependencies, trying to gracefully fallback from one library to another in the event one of them was missing, eventually dropping some features when no library was available. This resulted in complex and hard to maintain code for the MoviePy team, as well as fragmented and hard to understand environment for the users. -With v2.0 the MoviePy team tried to offer a simpler, smaller and more unified dependicy list, with focusing on ``pillow`` for all complex image manipulation, and dropping altogether the usage of ``ImageMagick``, ``PyGame``, ``OpenCV``, ``scipy``, ``scikit``, and a few others. +With v2.0 the MoviePy team tried to offer a simpler, smaller and more unified dependency list, with focusing on ``pillow`` for all complex image manipulation, and dropping altogether the usage of ``ImageMagick``, ``PyGame``, ``OpenCV``, ``scipy``, ``scikit``, and a few others. Removed features ----------------- @@ -88,30 +88,30 @@ Sadly, reducing the scope of MoviePy and limiting the external libraries mean th - ``moviepy.video.tools.segmenting`` - ``moviepy.video.io.sliders`` -Miscleanous signature changes +Miscellaneous signature changes ------------------------------ -When updating the API and moving from previous libraries to ``pillow``, some miscleanous changes also happen, meaning some methods signatures may have changed. +When updating the API and moving from previous libraries to ``pillow``, some miscellaneous changes also happen, meaning some methods signatures may have changed. You should check the new signatures if you used any of the following: -- ``TextClip`` some arguments named have changed and a path to a font file is now needed at object instanciation +- ``TextClip`` some arguments named have changed and a path to a font file is now needed at object instantiation - ``clip.resize`` is now ``clip.resized`` - ``clip.crop`` is now ``clip.cropped`` - ``clip.rotate`` is now ``clip.rotated`` - Any previous ``Clip`` method not starting by ``with_`` now probably start with it -Why all thoses changes and updating from v1.0 to v2.0? +Why all these changes and updating from v1.0 to v2.0? ------------------------------------------------------- -You may ask yourself why all thoses changes was introduced? The answer is: time. +You may ask yourself why were all these changes introduced? The answer is: time. MoviePy have seen many evolution since his first release and have became kind of a complex project, with ambitions sometimes too important in regards to available manpower on the development team. -Over time, as in any project, inconsistencies have been introduced in order to support new functionnalities without breaking current API, and some initial choices no longer reflected the current state of things. +Over time, as in any project, inconsistencies have been introduced in order to support new functionalities without breaking current API, and some initial choices no longer reflected the current state of things. Due to multiple factors, MoviePy have also undergone a long period of time during which the main version distributed through PiPy diverged from the GitHub distributed version, introducing confusion and chaos. -In a global effort to simplify futur development and limit confusion by providing a unified environment, it has been decided to release a new major version including the many evolutions than happened over the years, which meant breaking changes, and so a new major version released was required. +In a global effort to simplify future development and limit confusion by providing a unified environment, it has been decided to release a new major version including the many evolutions than happened over the years, which meant breaking changes, and so a new major version released was required. -For thoses interested in how and why all of thoses things have been decided, you can find a lot of the discussion that went into this in GitHub issues `#1874 `_, `#1089 `_ and `#2012 `_. \ No newline at end of file +For anyone interested in how and why all of these things have been decided, you can find a lot of the discussion that went into this in GitHub issues `#1874 `_, `#1089 `_ and `#2012 `_. \ No newline at end of file diff --git a/docs/index.rst b/docs/index.rst index cc2ca3745..31f6baf5b 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -32,7 +32,7 @@ and manipulation tools for the `Python `__ programming :shadow: md New to *MoviePy*? Check out the getting started guides. They contain instructions - to install *MoviePy'* as well as introduction concepts and tutorials. + to install *MoviePy* as well as introduction concepts and tutorials. +++ @@ -88,7 +88,7 @@ and manipulation tools for the `Python `__ programming Saw a typo in the documentation? Want to improve existing functionalities? The contributing guidelines will guide - you through the process of improving moviepy. + you through the process of improving *MoviePy*. +++ diff --git a/docs/user_guide/compositing.rst b/docs/user_guide/compositing.rst index 4078ed14e..27501b6f2 100644 --- a/docs/user_guide/compositing.rst +++ b/docs/user_guide/compositing.rst @@ -33,7 +33,7 @@ Concatenation can be done very easily with the function :py:func:`~moviepy.video The ``final_clip`` is a clip that plays the clips 1, 2, and 3 one after the other. .. note:: - The clips do not need to be the same size. If they arent's they will all appear centered in a clip large enough to contain the biggest of them, with optionally a color of your choosing to fill the background. + The clips do not need to be the same size. If they aren't, they will all appear centered in a clip large enough to contain the biggest of them, with optionally a color of your choosing to fill the background. For more info, see :py:func:`~moviepy.video.compositing.CompositeVideoClip.concatenate_videoclips`. @@ -73,7 +73,7 @@ Unless ``clip3`` and/or ``clip2`` have masks which hide parts of them. To do so, just pass the size of the final composition as ``size`` parameter of :py:class:`~moviepy.video.compositing.CompositeVideoClip.CompositeVideoClip`. For now we have stacked multiple clip on top of each others, but this is obviously not enough for doing real video compositing. -For that, we will need to change when some clip start et stop to play, as well as define the x:y, position of thoses clips in the final video. +For that, we will need to change when some clip starts and stops playing, as well as define the x:y, position of these clips in the final video. For more info, see :py:class:`~moviepy.video.compositing.CompositeVideoClip.CompositeVideoClip`. @@ -111,7 +111,7 @@ When indicating the position keep in mind that the ``y`` coordinate has its zero Adding transitions effects """""""""""""""""""""""""" -The last part of composition is adding transition effects. For example, when a clip start while another is still playing, it would be nice to make the new one fadein instead of showing abruptly. +The last part of composition is adding transition effects. For example, when a clip start while another is still playing, it would be nice to make the new one fade-in instead of showing abruptly. To do so, we can use the transitions offered by MoviePy in :py:mod:`~moviepy.video.compositing.transitions`, like :py:func:`~moviepy.video.compositing.transitions.crossfadein` : @@ -119,7 +119,7 @@ To do so, we can use the transitions offered by MoviePy in :py:mod:`~moviepy.vid :language: python -MoviePy offer only few transitions in :py:mod:`~moviepy.video.compositing.transitions`. But technically, transitions are mostly effects applyed to the mask of a clip ! +MoviePy offer only few transitions in :py:mod:`~moviepy.video.compositing.transitions`. But technically, transitions are mostly effects applied to the mask of a clip! That means you can actually use any of the already existing effects, and use them as transitions by applying them on the mask of your clip (see . For more info, see :py:mod:`~moviepy.video.compositing.transitions` and :py:mod:`moviepy.video.fx`. @@ -130,7 +130,7 @@ Compositing audio clips When you mix video clips together, MoviePy will automatically compose their respective audio tracks to form the audio track of the final clip, so you don't need to worry about compositing these tracks yourself. -If you want to make a custom audiotrack from several audio sources, audio clips can be mixed together like video clips, with :py:class:`~moviepy.audio.AudioClip.CompositeAudioClip` and :py:func:`~moviepy.audio.AudioClip.concatenate_audioclips`: +If you want to make a custom audio track from several audio sources, audio clips can be mixed together like video clips, with :py:class:`~moviepy.audio.AudioClip.CompositeAudioClip` and :py:func:`~moviepy.audio.AudioClip.concatenate_audioclips`: .. literalinclude:: /_static/code/user_guide/compositing/CompositeAudioClip.py :language: python diff --git a/docs/user_guide/create_effects.rst b/docs/user_guide/create_effects.rst index 5866ce7d6..8eeda09fe 100644 --- a/docs/user_guide/create_effects.rst +++ b/docs/user_guide/create_effects.rst @@ -3,7 +3,7 @@ Creating your own effects ======================================================== -In addition to the existings effects already offered by MoviePy, we can create our own effects to modify a clip as we want. +In addition to the existing effects already offered by MoviePy, we can create our own effects to modify a clip however we want. Why creating your own effects? @@ -15,10 +15,10 @@ For simple enough tasks, we've seen that we can :ref:`modifying#filters`. Though - We cannot pass pass arguments to them - They are hard to maintain and re-use -To allow for more complexe and reusable clip modifications, we can create our own custom effects, that we will later apply with :py:func:`~moviepy.Clip.Clip.with_effects`. +To allow for more complex and reusable clip modifications, we can create our own custom effects, that we will later apply with :py:func:`~moviepy.Clip.Clip.with_effects`. For example, imagine we want to add a progress bar to a clip, to do so we will not only need the time and image of the current frame, but also the total duration of the clip. -We will also probably want to be able to pass parameters to define the apparence of the progress bar, such as color or height. This is a perfect task for an effect! +We will also probably want to be able to pass parameters to define the appearance of the progress bar, such as color or height. This is a perfect task for an effect! Creating an effect @@ -26,7 +26,7 @@ Creating an effect In MoviePy, effects are objects of type :py:class:`moviepy.Effect.Effect`, which is the base ``abstract class`` for all effects (kind of the same as :py:class:`~moviepy.Clip.Clip` is the base for all :py:class:`~moviepy.video.VideoClip.VideoClip` and :py:class:`~moviepy.audio.AudioClip.AudioClip`). -So, to create an effect, we will need to inherint the :py:class:`~moviepy.Effect.Effect` class, and do two things: +So, to create an effect, we will need to inherit the :py:class:`~moviepy.Effect.Effect` class, and do two things: - Create an ``__init__`` method to be able to received the parameters of our effect. - Implement the inherited :py:meth:`~moviepy.Effect.Effect.apply` method, which must take as an argument the clip we want to modify, and return the modified version. diff --git a/docs/user_guide/index.rst b/docs/user_guide/index.rst index bb4b162c5..4013de0c8 100644 --- a/docs/user_guide/index.rst +++ b/docs/user_guide/index.rst @@ -4,9 +4,9 @@ The MoviePy User Guide ------------------------------ -The User Guide covers all of MoviePy main concepts grouped by tasks (loading, editing, composing, rendering), with a presentation of the differents concept/elements relative to the tasks, as well of short code example. +The User Guide covers all of MoviePy's main concepts grouped by tasks (loading, editing, composing, rendering), with a presentation of the different concept/elements relative to the tasks along with short code example. -It is a good place for users whishing to understand more precisely one of these aspects and to discover the different MoviePy elements relative to it. +It is a good place for users wishing to understand more precisely one of these aspects and to discover the different MoviePy elements relative to it. For users wanting to have a quick overview of how to use MoviePy, a better place to start is the :ref:`getting_started` section, and more specifically the :ref:`moviepy_10_minutes` tutorial. diff --git a/docs/user_guide/loading.rst b/docs/user_guide/loading.rst index 28bdb87d0..b27b64aaa 100644 --- a/docs/user_guide/loading.rst +++ b/docs/user_guide/loading.rst @@ -8,7 +8,7 @@ The first step for making a video with MoviePy is to load the resources you wish In this section we present the different sorts of clips and how to load them. For information on modifying a clip, see :ref:`modifying`. For how to put clips together see :ref:`compositing`. And for how to see/save theme, see :ref:`rendering` (we will usually save them in example, but we wont explain here). -There's a lot of different resources you can use with MoviePy, and you will load those differents resources with different subtypes of :py:class:`~moviepy.Clip.Clip`, and more preciselly of :py:class:`~moviepy.audio.AudioClip.AudioClip` for any audio element, or :py:class:`~moviepy.video.VideoClip.VideoClip` for any visual element. +There's a lot of different resources you can use with MoviePy, and you will load different resources with different subtypes of :py:class:`~moviepy.Clip.Clip`, and more precisely of :py:class:`~moviepy.audio.AudioClip.AudioClip` for any audio element, or :py:class:`~moviepy.video.VideoClip.VideoClip` for any visual element. The following code summarizes the base clips that you can create with moviepy: @@ -19,10 +19,10 @@ The following code summarizes the base clips that you can create with moviepy: The best to understand all these clips more thoroughly is to read the full documentation for each in the :ref:`reference_manual`. -Realasing resources by closing a clip +Releasing resources by closing a clip --------------------------------------- -When you create some types of clip instances - e.g. ``VideoFileClip`` or ``AudioFileClip`` - MoviePy creates a subprocess and locks the file. In order to release those resources when you are finished you should call the ``close()`` method. +When you create some types of clip instances - e.g. ``VideoFileClip`` or ``AudioFileClip`` - MoviePy creates a subprocess and locks the file. In order to release these resources when you are finished you should call the ``close()`` method. This is more important for more complex applications and is particularly important when running on Windows. While Python's garbage collector should eventually clean up the resources for you, closing them makes them available earlier. @@ -59,7 +59,7 @@ A video clip can carry around an audio clip (:py:class:`~moviepy.audio.AudioClip Animated clips ~~~~~~~~~~~~~~~ -Thoses are clips whose image will change in time, and who have a duration and a number of Frames Per Second. +These are clips whose image will change over time, and which have a duration and a number of Frames Per Second. VideoClip """""""""" @@ -141,7 +141,7 @@ UpdatedVideoClip This is particularly practical in science where some algorithm needs to make some steps before a new frame can be generated, or maybe when trying to make a video based on a live exterior context. -When you use this, you pass a world object to it. A world object is an object who respect thoses 3 rules : +When you use this, you pass a world object to it. A world object is an object who respect these 3 rules: #. It has a ``clip_t`` property, indicating the current world time. #. It has an ``update()`` method, that will update the world state and is responsible for increasing ``clip_t`` when a new frame can be drown. @@ -157,7 +157,7 @@ On :py:meth:`~moviepy.video.io.VideoClip.UpdatedVideoClip.get_frame` call, your Unanimated clips ~~~~~~~~~~~~~~~~ -Thoses are clips whose image will, at least before modifications, stay the same. By default they have no duration nor FPS. Meaning you will need to define thoses if you try to do operation needing such information (for example rendering). +These are clips whose image will, at least before modifications, stay the same. By default they have no duration nor FPS, meaning you will need to define them before doing operations needing such information (for example, rendering). ImageClip @@ -177,8 +177,8 @@ TextClip A :py:class:`~moviepy.video.VideoClip.TextClip` is a clip that will turn a text string into an image clip. -:py:class:`~moviepy.video.VideoClip.TextClip` accept many parameters, letting you configure the apparence of the text, such as font and font size, -color, interlining, text alignement, etc. +:py:class:`~moviepy.video.VideoClip.TextClip` accept many parameters, letting you configure the appearance of the text, such as font and font size, +color, interlining, text alignment, etc. The font you want to use must be an `OpenType font `_, and you will set it by passing the path to the font file. @@ -188,15 +188,15 @@ Here are a few example of using :py:class:`~moviepy.video.VideoClip.TextClip` : :language: python .. note:: - The parameter ``method`` let you define if text should be written and overflow if too long (``label``) or be automatically breaked (``caption``). + The parameter ``method`` let you define if text should be written and overflow if too long (``label``) or be automatically broken over multiple lines (``caption``). -For a more detailed explaination of all the parameters, see :py:class:`~moviepy.video.VideoClip.TextClip`. +For a more detailed explanation of all the parameters, see :py:class:`~moviepy.video.VideoClip.TextClip`. ColorClip """"""""""""""" -A :py:class:`~moviepy.video.VideoClip.ColorClip` is a clip that will return an image of only one color. It is sometimes usefull when doing compositing (see :ref:`compositing`). +A :py:class:`~moviepy.video.VideoClip.ColorClip` is a clip that will return an image of only one color. It is sometimes useful when doing compositing (see :ref:`compositing`). .. literalinclude:: /_static/code/user_guide/loading/ColorClip.py :language: python @@ -213,7 +213,7 @@ Masks are a special kind of :py:class:`~moviepy.video.VideoClip.VideoClip` with When a clip as a mask attached to it, this mask will indicate which pixels will be visible when the clip is composed with other clips (see :ref:`compositing`). Masks are also used to define transparency when you export the clip as GIF file or as a PNG. -The fundamental difference between masks and standard clips is that standard clips output frames with 3 components (R-G-B) per pixel, comprised between 0 and 255, while a mask has just one composant per pixel, between 0 and 1 (1 indicating a fully visible pixel and 0 a transparent pixel). Seen otherwise, a mask is always in greyscale. +The fundamental difference between masks and standard clips is that standard clips output frames with 3 components (R-G-B) per pixel, comprised between 0 and 255, while a mask has just one component per pixel, between 0 and 1 (1 indicating a fully visible pixel and 0 a transparent pixel). Seen otherwise, a mask is always in greyscale. When you create or load a clip that you will use as a mask you need to declare it. You can then attach it to a clip with the same dimensions : @@ -223,7 +223,7 @@ When you create or load a clip that you will use as a mask you need to declare i .. note:: In the case of video and image files, if these are not already black and white they will be converted automatically. - Also, when you load an image with an *alpha layer*, like a PNG, MoviePy will use this layer as a mask, except if you pass ``transparent=False``. + Also, when you load an image with an *alpha layer*, like a PNG, MoviePy will use this layer as a mask unless you pass ``transparent=False``. Any video clip can be turned into a mask with :py:meth:`~moviepy.video.VideoClip.VideoClip.to_mask`, and a mask can be turned to a standard RGB video clip with :py:meth:`~moviepy.video.VideoClip.VideoClip.to_RGB()`. @@ -255,9 +255,9 @@ For more, see :py:class:`~moviepy.audio.AudioClip.AudioClip`. AudioFileClip ~~~~~~~~~~~~~~~~~~~~ -:py:class:`~moviepy.audio.io.AudioFileClip.AudioFileClip` is used to load an audio file, this is probably the only kind of audio clip you will use. +:py:class:`~moviepy.audio.io.AudioFileClip.AudioFileClip` is used to load an audio file. This is probably the only kind of audio clip you will use. -You simply pass him the file you want to load : +You simply pass it the file you want to load : .. literalinclude:: /_static/code/user_guide/loading/AudioFileClip.py :language: python diff --git a/docs/user_guide/modifying.rst b/docs/user_guide/modifying.rst index 23b857b1d..122dce70d 100644 --- a/docs/user_guide/modifying.rst +++ b/docs/user_guide/modifying.rst @@ -20,7 +20,7 @@ Clip copy during modification The first thing you must know is that when modifying a clip, MoviePy **will never modify that clip directly**. Instead it will return **a modified copy of the original** and let the original untouched. This is known as out-place instead of in-place behavior. -To illustrate : +To illustrate: .. literalinclude:: /_static/code/user_guide/effects/modify_copy_example.py :language: python @@ -39,7 +39,7 @@ Time representations in MoviePy ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Many methods that we will see accept duration or timepoint as arguments. For instance :py:meth:`clip.subclipped(t_start, t_end) ` which cuts the clip between two timepoints. -MoviePy usually accept duration and timepoint as either : +MoviePy usually accept duration and timepoint as either: * a number of seconds as a ``float``. * a ``tuple`` with ``(minutes, seconds)`` or ``(hours, minutes, seconds)``. @@ -53,14 +53,14 @@ Modify a clip using the ``with_*`` methods The first way to modify a clip is by modifying internal properties of your object, thus modifying his behavior. -Thoses methods usually starts with the prefix ``with_`` or ``without_``, indicating that they will return a copy of the clip with the properties modified. +These methods usually start with the prefix ``with_`` or ``without_``, indicating that they will return a copy of the clip with the properties modified. -So, you may write something like : +So, you may write something like: .. literalinclude:: /_static/code/user_guide/effects/using_with_methods.py :language: python -In addition to the ``with_*`` methods, a handful of very common methods are also accessible under shorter name, thoses are: +In addition to the ``with_*`` methods, a handful of very common methods are also accessible under shorter names: - :py:meth:`~moviepy.video.VideoClip.VideoClip.resized` - :py:meth:`~moviepy.video.VideoClip.VideoClip.crop` @@ -79,17 +79,17 @@ The second way to modify a clip is by using effects that will modify the frames MoviePy come with many effects implemented in :py:mod:`moviepy.video.fx` for visual effects and :py:mod:`moviepy.audio.fx` for audio effects. For practicality, these two modules are loaded in MoviePy as ``vfx`` and ``afx``, letting you import them as ``from moviepy import vfx, afx``. -To use thoses effects, you simply need to instanciate them as object and apply them on your :py:class:`~moviepy.Clip.Clip` using method :py:meth:`~moviepy.Clip.Clip.with_effects`, with a list of :py:class:`~moviepy.Effect.Effect` objects you want to apply. +To use these effects, you simply need to instantiate them as object and apply them on your :py:class:`~moviepy.Clip.Clip` using method :py:meth:`~moviepy.Clip.Clip.with_effects`, with a list of :py:class:`~moviepy.Effect.Effect` objects you want to apply. For convenience the effects are also dynamically added as method of :py:class:`~moviepy.video.VideoClip.VideoClip` and :py:class:`~moviepy.video.AudioClip.AudioClip` classes at runtime, letting you call them as simple method of your clip. -So, you may write something like : +So, you may write something like: .. literalinclude:: /_static/code/user_guide/effects/using_effects.py :language: python .. note:: - MoviePy effects are automatically applied to both the sound and the mask of the clip if it is relevant, so that you don’t have to worry about modifying these. + MoviePy effects are automatically applied to both the sound and the mask of the clip if it is relevant, so that you don't have to worry about modifying these. For a list of those effects, see :py:mod:`moviepy.video.fx` and :py:mod:`moviepy.audio.fx`. @@ -97,18 +97,18 @@ In addition to the effects already provided by MoviePy, you can obviously :ref:` .. _modifying#filters: -Modify a clip apparence and timing using filters +Modify a clip appearance and timing using filters ---------------------------------------------------------- -In addition to modify a clip properties and using effects, you can also modify the apparence or timing of a clip by using your own custom *filters* with :py:func:`~moviepy.Clip.Clip.time_transform`, :py:func:`~moviepy.Clip.Clip.image_transform`, and more generally with :py:func:`~moviepy.Clip.Clip.transform`. +In addition to modifying a clip's properties and using effects, you can also modify the appearance or timing of a clip by using your own custom *filters* with :py:func:`~moviepy.Clip.Clip.time_transform`, :py:func:`~moviepy.Clip.Clip.image_transform`, and more generally with :py:func:`~moviepy.Clip.Clip.transform`. -All thoses methods works by taking as first parameter a callback function that will receive either a clip frame, a timepoint, or both, and return a modified version of thoses. +All these methods work by taking as first parameter a callback function that will receive either a clip frame, a timepoint, or both, and return a modified version of these. Modify only the timing of a Clip ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ You can change the timeline of the clip with :py:meth:`time_transform(your_filter) `. -Where ``your_filter`` is a callback function taking clip time as a parameter and returning a new time : +Where ``your_filter`` is a callback function taking clip time as a parameter and returning a new time: .. literalinclude:: /_static/code/user_guide/effects/time_transform.py :language: python @@ -121,11 +121,11 @@ Now the clip ``modified_clip1`` plays three times faster than ``my_clip``, while If you wish to also modify audio and/or mask you can provide the parameter ``apply_to`` with either ``'audio'``, ``'mask'``, or ``['audio', 'mask']``. -Modifying only the apparence of a Clip +Modifying only the appearance of a Clip ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -For :py:class:`~moviepy.video.VideoClip.VideoClip`, you can change the apparence of the clip with :py:meth:`image_transform(your_filter) `. -Where ``your_filter`` is a callback function, taking clip frame (a numpy array) as a parameter and returning the transformed frame : +For :py:class:`~moviepy.video.VideoClip.VideoClip`, you can change the appearance of the clip with :py:meth:`image_transform(your_filter) `. +Where ``your_filter`` is a callback function, taking clip frame (a numpy array) as a parameter and returning the transformed frame: .. literalinclude:: /_static/code/user_guide/effects/image_transform.py :language: python @@ -139,7 +139,7 @@ Now the clip ``modified_clip1`` will have his green and blue canals inverted. Sometimes need to treat clip frames and mask frames in a different way. To distinguish between the two, you can always look at their shape, clips are ``H*W*3``, and masks ``H*W``. -Modifying both the apparence and the timing of a Clip +Modifying both the appearance and the timing of a Clip ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Finally, you may want to process the clip by taking into account both the time and the frame picture, for example to apply visual effects variating with time. @@ -156,6 +156,6 @@ This will scroll down the clip, with a constant height of 360 pixels. .. note:: When programming a new effect, whenever it is possible, prefer using ``time_transform`` and ``image_transform`` instead of ``transform`` when implementing new effects. - The reason is that, though they both internally relly on ``transform`` when these effects are applied to ``ImageClip`` objects, MoviePy will recognize they only need to be applied once instead of on each frame, resulting in faster renderings. + The reason is that, though they both internally rely on ``transform`` when these effects are applied to ``ImageClip`` objects, MoviePy will recognize they only need to be applied once instead of on each frame, resulting in faster renderings. To keep things simple, we have only addressed the case of :py:class:`~moviepy.video.VideoClip.VideoClip`, but know that the same principle applies to :py:class:`~moviepy.audio.AudioClip.AudioClip`, except that instead of a picture frame, you will have an audio frame, which is also a numpy array. \ No newline at end of file diff --git a/docs/user_guide/rendering.rst b/docs/user_guide/rendering.rst index 52474c530..1b1531755 100644 --- a/docs/user_guide/rendering.rst +++ b/docs/user_guide/rendering.rst @@ -16,7 +16,7 @@ Preview a clip as a video ~~~~~~~~~~~~~~~~~~~~~~~~~~ .. warning:: - You must have ``FFPLAY`` installed and accessible to MoviePy to be able to use :py:func:`~moviepy.video.io.preview.preview`. + You must have ``ffplay`` installed and accessible to MoviePy to be able to use :py:func:`~moviepy.video.io.preview.preview`. If you'r not sure, take a look :ref:`install#binaries` The first thing you can do is to preview your clip as a video, by calling method :py:func:`~moviepy.video.io.preview.preview` on your clip: @@ -29,7 +29,7 @@ You will probably frequently want to preview only a small portion of your clip, .. note:: It is quite frequent for a clip preview to be out of sync, or to play slower than it should. It means that your computer is not powerful enough to render the clip in real time. - Don’t hesitate to play with the options of preview: for instance, lower the fps of the sound (11000 Hz is still fine) and the video. Also, downsizing your video with resize can help. + Don't hesitate to play with the options of preview: for instance, lower the fps of the sound (11000 Hz is still fine) and the video. Also, downsizing your video with resize can help. For more info, see :py:func:`~moviepy.video.io.preview.preview`. @@ -40,7 +40,7 @@ For more info, see :py:func:`~moviepy.video.io.preview.preview`. Preview just one frame of a clip ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -In a lot of situation, you dont really need to preview your all clip, seeing only one frame is enough to see how it looks like and to make sure everything goes as expected. +In a lot of situation, you don't really need to preview your all clip, seeing only one frame is enough to see how it looks like and to make sure everything goes as expected. To do so, you can use the method :py:func:`~moviepy.video.io.preview.show` on your clip, passing the frame time as an argument: @@ -96,7 +96,7 @@ MoviePy can find the a default codec name for the most common file extensions. I There are many many options when you are writing a video (bitrate, parameters of the audio writing, file size optimization, number of processors to use, etc.), and we will not go in details into each. So, for more info, see :py:meth:`~moviepy.video.VideoClip.VideoClip.write_videofile`. .. note:: - Though you are encouraged to play with settings of ``write_videofile``, know that lowering the optimization preset, or increasing the number of threads will not necessarly + Though you are encouraged to play with settings of ``write_videofile``, know that lowering the optimization preset or increasing the number of threads will not necessarily improve the rendering time, as the bottleneck may be on MoviePy computation of each frame and not in ffmpeg encoding. Also, know that it is possible to pass additional parameters to ffmpeg command line invoked by MoviePy by using the ``ffmpeg_params`` argument. diff --git a/moviepy/audio/io/ffmpeg_audiowriter.py b/moviepy/audio/io/ffmpeg_audiowriter.py index db8c808d8..e1f78169e 100644 --- a/moviepy/audio/io/ffmpeg_audiowriter.py +++ b/moviepy/audio/io/ffmpeg_audiowriter.py @@ -23,7 +23,7 @@ class FFMPEG_AudioWriter: Size (width,height) in pixels of the output video. fps_input - Frames per second of the input audio (given by the AUdioClip being + Frames per second of the input audio (given by the AudioClip being written down). codec diff --git a/moviepy/audio/io/ffplay_audiopreviewer.py b/moviepy/audio/io/ffplay_audiopreviewer.py index 62666128d..e1217ab56 100644 --- a/moviepy/audio/io/ffplay_audiopreviewer.py +++ b/moviepy/audio/io/ffplay_audiopreviewer.py @@ -15,7 +15,7 @@ class FFPLAY_AudioPreviewer: ---------- fps_input - Frames per second of the input audio (given by the AUdioClip being + Frames per second of the input audio (given by the AudioClip being written down). nbytes: @@ -36,8 +36,8 @@ def __init__( # order is important cmd = [ FFPLAY_BINARY, - "-autoexit", # If you dont precise, ffplay dont stop at end - "-nodisp", # If you dont precise a window is + "-autoexit", # If you don't precise, ffplay won't stop at end + "-nodisp", # If you don't precise a window is "-f", "s%dle" % (8 * nbytes), "-ar", diff --git a/moviepy/video/VideoClip.py b/moviepy/video/VideoClip.py index e92e7d5b9..fd43a81a2 100644 --- a/moviepy/video/VideoClip.py +++ b/moviepy/video/VideoClip.py @@ -989,7 +989,7 @@ def cropped( ): """Returns a new clip in which just a rectangular subregion of the original clip is conserved. x1,y1 indicates the top left corner and - x2,y2 is the lower right corner of the croped region. + x2,y2 is the lower right corner of the cropped region. All coordinates are in pixels. Float numbers are accepted. For info on the parameters, please see ``vfx.Crop`` """ diff --git a/moviepy/video/io/ffplay_previewer.py b/moviepy/video/io/ffplay_previewer.py index 28f3569ab..9007b33cc 100644 --- a/moviepy/video/io/ffplay_previewer.py +++ b/moviepy/video/io/ffplay_previewer.py @@ -35,7 +35,7 @@ def __init__( # order is important cmd = [ FFPLAY_BINARY, - "-autoexit", # If you dont precise, ffplay dont stop at end + "-autoexit", # If you don't precise, ffplay won't stop at end "-f", "rawvideo", "-pixel_format", @@ -105,9 +105,9 @@ def ffplay_preview_video( pixel_format : str, optional Warning: This is not used anywhere in the code and should probably - be remove. + be removed. It is believed pixel format rgb24 does not work properly for now because - it require applying mask on CompositeVideoClip and thoses are believed to + it requires applying a mask on CompositeVideoClip and that is believed to not be working. Pixel format for the output video file, ``rgb24`` for normal video, ``rgba`` diff --git a/tests/test_doc_examples.py b/tests/test_doc_examples.py index 2e5ac5c2f..5e28db4dd 100644 --- a/tests/test_doc_examples.py +++ b/tests/test_doc_examples.py @@ -1,4 +1,4 @@ -"""Try to run all the documentation examples with runpy and check they dont raise +"""Try to run all the documentation examples with runpy and check they don't raise exceptions. """