0-Pht d Z ddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z ddl m
Z
mZ ej e Zej d rdZn`_. It is faster and more
flexible than the plugin documented here. Check the :mod:`pyav
plugin's documentation ` for more information about
this plugin.
Backend Library: https://github.com/imageio/imageio-ffmpeg
.. note::
To use this plugin you have to install its backend::
pip install imageio[ffmpeg]
The ffmpeg format provides reading and writing for a wide range of movie formats
such as .avi, .mpeg, .mp4, etc. as well as the ability to read streams from
webcams and USB cameras. It is based on ffmpeg and is inspired by/based `moviepy
`_ by Zulko.
Parameters for reading
----------------------
fps : scalar
The number of frames per second of the input stream. Default None (i.e.
read at the file's native fps). One can use this for files with a
variable fps, or in cases where imageio is unable to correctly detect
the fps. In case of trouble opening camera streams, it may help to set an
explicit fps value matching a framerate supported by the camera.
loop : bool
If True, the video will rewind as soon as a frame is requested
beyond the last frame. Otherwise, IndexError is raised. Default False.
Setting this to True will internally call ``count_frames()``,
and set the reader's length to that value instead of inf.
size : str | tuple
The frame size (i.e. resolution) to read the images, e.g.
(100, 100) or "640x480". For camera streams, this allows setting
the capture resolution. For normal video data, ffmpeg will
rescale the data.
dtype : str | type
The dtype for the output arrays. Determines the bit-depth that
is requested from ffmpeg. Supported dtypes: uint8, uint16.
Default: uint8.
pixelformat : str
The pixel format for the camera to use (e.g. "yuyv422" or
"gray"). The camera needs to support the format in order for
this to take effect. Note that the images produced by this
reader are always RGB.
input_params : list
List additional arguments to ffmpeg for input file options.
(Can also be provided as ``ffmpeg_params`` for backwards compatibility)
Example ffmpeg arguments to use aggressive error handling:
['-err_detect', 'aggressive']
output_params : list
List additional arguments to ffmpeg for output file options (i.e. the
stream being read by imageio).
print_info : bool
Print information about the video file as reported by ffmpeg.
Parameters for writing
----------------------
fps : scalar
The number of frames per second. Default 10.
codec : str
the video codec to use. Default 'libx264', which represents the
widely available mpeg4. Except when saving .wmv files, then the
defaults is 'msmpeg4' which is more commonly supported for windows
quality : float | None
Video output quality. Default is 5. Uses variable bit rate. Highest
quality is 10, lowest is 0. Set to None to prevent variable bitrate
flags to FFMPEG so you can manually specify them using output_params
instead. Specifying a fixed bitrate using 'bitrate' disables this
parameter.
bitrate : int | None
Set a constant bitrate for the video encoding. Default is None causing
'quality' parameter to be used instead. Better quality videos with
smaller file sizes will result from using the 'quality' variable
bitrate parameter rather than specifying a fixed bitrate with this
parameter.
pixelformat: str
The output video pixel format. Default is 'yuv420p' which most widely
supported by video players.
input_params : list
List additional arguments to ffmpeg for input file options (i.e. the
stream that imageio provides).
output_params : list
List additional arguments to ffmpeg for output file options.
(Can also be provided as ``ffmpeg_params`` for backwards compatibility)
Example ffmpeg arguments to use only intra frames and set aspect ratio:
['-intra', '-aspect', '16:9']
ffmpeg_log_level: str
Sets ffmpeg output log level. Default is "warning".
Values can be "quiet", "panic", "fatal", "error", "warning", "info"
"verbose", or "debug". Also prints the FFMPEG command being used by
imageio if "info", "verbose", or "debug".
macro_block_size: int
Size constraint for video. Width and height, must be divisible by this
number. If not divisible by this number imageio will tell ffmpeg to
scale the image up to the next closest size
divisible by this number. Most codecs are compatible with a macroblock
size of 16 (default), some can go smaller (4, 8). To disable this
automatic feature set it to None or 1, however be warned many players
can't decode videos that are odd in size and some codecs will produce
poor results or fail. See https://en.wikipedia.org/wiki/Macroblock.
audio_path : str | None
Audio path of any audio that needs to be written. Defaults to nothing,
so no audio will be written. Please note, when writing shorter video
than the original, ffmpeg will not truncate the audio track; it
will maintain its original length and be longer than the video.
audio_codec : str | None
The audio codec to use. Defaults to nothing, but if an audio_path has
been provided ffmpeg will attempt to set a default codec.
Notes
-----
If you are using anaconda and ``anaconda/ffmpeg`` you will not be able to
encode/decode H.264 (likely due to licensing concerns). If you need this
format on anaconda install ``conda-forge/ffmpeg`` instead.
You can use the ``IMAGEIO_FFMPEG_EXE`` environment variable to force using a
specific ffmpeg executable.
To get the number of frames before having read them all, you can use the
``reader.count_frames()`` method (the reader will then use
``imageio_ffmpeg.count_frames_and_secs()`` to get the exact number of frames,
note that this operation can take a few seconds on large files). Alternatively,
the number of frames can be estimated from the fps and duration in the meta data
(though these values themselves are not always present/reliable).
N )Format
image_as_uintwindshowlinux video4linux2darwin avfoundationzunknown-cam-formatFc t d )NzYimageio.ffmpeg.download() has been deprecated. Use 'pip install imageio-ffmpeg' instead.' RuntimeError) directoryforce_downloads V/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/imageio/plugins/ffmpeg.pydownloadr s
5 c ( t j S )z+Wrapper for imageio_ffmpeg.get_ffmpeg_exe())imageio_ffmpegget_ffmpeg_exe r r get_exer s ( * **r c j e Zd ZdZd Zd Z G d dej Z G d dej ZdS ) FfmpegFormatzSRead/Write ImageResources using FFMPEG.
See :mod:`imageio.plugins.ffmpeg`
c ^ t j d|j rdS |j | j v rdS d S )N T)rematchfilename extension
extensionsselfrequests r _can_readzFfmpegFormat._can_read s? 8OW%5 6 6 4 / /4 0 /r c & |j | j v rdS d S )NT)r r! r" s r
_can_writezFfmpegFormat._can_write s / /4 0 /r c j e Zd ZdZdZd Z ddZd Zd Zd Z d Z
d Z dd Z dd
Z
d ZdS )FfmpegFormat.ReaderNc < t j d rd| j j dd z S t j d rt
}| dddt d d
g}t j |t j
t j
d d d
} t |j | }n # t $ r t d|z w xY wd|z S t j d rt | }|S dS )Nr z/dev/ r z
-list_devicestrue-fz-idummyzutf-8TF)stdoutstderrencodingshellcheckz No ffdshow camera at index %i.zvideo=%sr
z??)sysplatform
startswithr$ _videor r
CAM_FORMATsprunPIPEparse_device_namesr1
IndexErrorstr)r# index
ffmpeg_apicmdcompleted_processnames r _get_cam_inputnamez&FfmpegFormat.Reader._get_cam_inputname s4 |&&w// ,
!4QrT!::: ((// )
+
--//# %'F 7 7 $
% % %!O-.?.FGGNDD! O O O$%E%MNNNO!D(( ((22
5zz ts ,C C$Fc
6 t | _ t | | _ |d | _ nPt |t r d|z | _ n0t |t r d|v r|| _ nt d |n$t |t st d |t j
d | _ n`t j
| | _ ddg}
| j j |
vr5t d
d |
|| _ |pg | _ |pg | _ | xj |pg z
c_ d | j _ t) j d | j j } | r| j j | j _ | j j r=t/ | d
} | | | _ n>| j | _ | j d d | _ d
| _ | j j dk rd| _ d
| _ nd| _ d| _ d| _ ddi| _! d | _" tG d | _$ | j r%| j j s| % | _$ | j$ | j! d< dx}
}| j j rctM j' ( dk r:dt | j vrd}
| j j) * dd sd}|
r6| j + dt tG d g |r6| j + d t tG d g | , nL# tZ $ r? |
r9t tG d | j d< | , n Y nw xY w| j j rt] | j/ | _0 d S d S ) Nz%ix%ixz"FFMPEG size must be tuple of "NxM"z FFMPEG pixelformat must be struint8uint16zdtype must be one of: {}z, r r+ ^z^^ rgb24rgb48ler r, pluginffmpeginfnframesFr
z
-framerateTfps -r )1r _ffmpeg_apibool _arg_loop _arg_size
isinstancetupler?
ValueErrornpdtype_dtyperD formatjoin_arg_pixelformat_arg_input_params_arg_output_paramsr$ r8 r r r intgrouprE _filenameget_local_filenamereplace_depth_pix_fmt_bytes_per_channel_pos_meta _lastreadfloat_nframes count_framesr6 systemlowerkwargsgetextend _initializer> FrameCatcher _read_gen_frame_catcher)r# loopsizer^ pixelformat
print_info
ffmpeg_params input_params
output_paramsrR allowed_dtypes regex_matchr@ need_input_fpsneed_output_fpss r _openzFfmpegFormat.Reader._open s .D !$ZZDN|!%D%((
G!(4 D#&&
G3$;;!% !EFFF" S11
C !ABBB} hw / / huoo ")8!4;#>99$299$))N:S:STT %0D !%1%7RD "&3&9rD # " "m&9r 9 " ""&DL (?DL4IJJK
<&*l&; #|"
CK - -a 0 011!%!8!8!?!?!% !@!@!B!B!% !7!7T!B!BDK{ 7** '
*+'' )
*+'DI"H-DJ !DN
"%LLDM~
4dl&9
4 $ 1 1 3 3
$(MDJy ! 05 4N_|"
+x'8'8'>'>'@'@H'L'L s4+A'B'BBB%)N|*..ud;; +&*O
N&--|Sr^^.LMMM
G'..c%))nn/EFFF
""""
! 14U2YY D*2.$$&&&& '&
|"
C&24>&B&B###
C
Cs N& &AO/.O/c | j | j d | _ | j "| j d | _ d S d S N)r{ stop_merz closer# s r _closezFfmpegFormat.Reader._closek sY ".#++---&*#~)$$&&&!% *)r c F | j j } || j d S )zCount the number of frames. Note that this can take a few
seconds for large files. Also note that it counts the number
of frames in the original video and does not take a given fps
into account.
r )rV count_frames_and_secsrg )r# cfs r rr z FfmpegFormat.Reader.count_framesu s& !7B2dn%%a( (r c | j S r )rq r s r _get_lengthz FfmpegFormat.Reader._get_length s
= r c | j r"| j t d k r
|| j z }|| j k r| j t d fS |dk rt
d || j k rt
d || j k s|| j dz k r| | n | || j z
dz
| \ }}|| _ |t | fS ) a1 Reads a frame at index. Note for coders: getting an
arbitrary frame in the video with ffmpeg can be painfully
slow if some decoding has to be done. This function tries
to avoid fectching arbitrary frames whenever possible, by
moving between adjacent frames.rP F)newr zFrame index must be >= 0zReached end of videod r+ )
rX rq rp rm ro dictr> rx _skip_frames _read_frame)r# r@ resultis_news r _get_dataz FfmpegFormat.Reader._get_data s ~
'$-%,,">"> & !!~t66 !;<<<$-'' !7888DI%%549s?+B+B$$U++++%%edi&7!&;<< r` )r# r@ iargsoargs starttime seek_slow seek_fastrR pix_fmtbpprfmetaerrerr_texts r rx z FfmpegFormat.Reader._initialize s ~)$$&&&EE
T+ +E|"
8$
++( Aj$*? @@E> 4dDN 33E "DJu$5 5 I . . % 1 %I!677%I!677 ~
0$//|"&&ud33
/DL / 677$#
.. T, ,E mG+ 77C !-B R5PU DN
|"
*, >2244D J%%d+++++
"3xxH 3<//AXMM $!7 H
%:AA L /
!
!!$."9"9";";<<<<<'')))))s F
G3AG..G3r+ c | t | D ]}| j | xj |z
c_ dS )z Reads and throws away n framesN)rangerz r rm )r# nis r r z FfmpegFormat.Reader._skip_frames sA 1XX
*
*'')))) IINIIIIr c | j d \ }}||z | j z | j z }| j r | j \ }}n| j }d}t | |k r!t dt | |fz t j
|| j }|
||| j f }|| _ ||fS )Nr} Tz#Frame is %i bytes, but expected %i.)r^ )rn rj rl r{ get_framerz r lenr r]
frombufferr_ copyreshapero )r# wh framesizesr r s r r z FfmpegFormat.Reader._read_frame s :f%DAqA +d.EEI "
/ 9 9 ; ; 66N++-- 1vv"""9SVVY !r ) FNNNFNNNN)r )r+ )__name__
__module__ __qualname__r{ rz rE r r rr r r r rx r r r r r Readerr) s - - - b h C h C h C h Cb & & & ) ) ) ! ! ! 0 0 02 N * N * N * N *` " " " " "r r c J e Zd ZdZ d
dZd Zd
Zd Zd ZdS )FfmpegFormat.WriterNr libx264yuv420pquiet c
t | _ | j | _ d | _ d | _ d | _ d S r )r rV r$ rh rg rk rj _size)
r# rR codecbitrater~ r r r ffmpeg_log_levelqualitymacro_block_size
audio_path audio_codecs
r r zFfmpegFormat.Writer._open s: .D !\ < < > >DN DM DK DJJJr c X | j "| j d | _ d S d S r )
_write_genr r s r r zFfmpegFormat.Writer._close. s1 *%%'''"& +*r c 8 |j d d \ }}||f}|j dk rdn |j d }t |d }|j j st j | }| j Zddddd }| |d | _ | j t d
|| _ || _ | || j k rt d || j k rt d | j
J | j
| d S )
Nr r+ )bitdepthgraygray8arL rgba)r+ r rK z%Image must have 1, 2, 3 or 4 channelsz+All images in a movie should have same sizez9All images in a movie should have same number of channels)shapendimr flags c_contiguousr] ascontiguousarrayr rv rk r\ rj rx r send)r# imr r r r} depthmaps r _append_dataz FfmpegFormat.Writer._append_data3 sA 8BQB>Gl)--i>>G <.22>BBHbL L / 3 3O D D JM T\ 0 4 4_ E E K KM ,-11-FFK #| 2 6 67I2 N N #| 2 6 67I4 P P ,00 tDDJ ,-11-FFK / 41 # . ; ;
= ' !1!1 ) +% ' < DO$
O & & & & &r ) r r Nr NNNr r r NN) r r r r r r r r rx r r r Writerr s
! $ * ' ' '
% % % % % %N
) ' ) ' ) ' ) ' ) 'r r N) r r r __doc__r% r' r r r r r r r r s
K" K" K" K" K" K" K" K"^
r' r' r' r' r' r' r' r' r' r'r r c * e Zd ZdZd Zd Zd Zd ZdS )ry aM Thread to keep reading the frame data from stdout. This is
useful when streaming from a webcam. Otherwise, if the user code
does not grab frames fast enough, the buffer will fill up, leading
to lag, and ffmpeg can also stall (experienced on Linux). The
get_frame() method always returns the last available image.
c || _ d | _ d| _ t j | _ t j | d| _ d| _ |
d S )NFT) _gen_frame
_frame_is_new threadingRLock_lockThread__init__daemon _should_stopstart)r# gens r r zFrameCatcher.__init__ s^ " _&&
!!$''' !
r c d| _ | r*t j d | (d S d S )NTMbP?)r is_alivetimesleepr s r r zFrameCatcher.stop_me sP mmoo Ju mmoo r c | j t j d | j | j 5 | j }d| _ | j |fcd d d S # 1 swxY w Y d S )Nr F)r r r r r )r# r s r r zFrameCatcher.get_frame s k! Ju k!
Z ' ''F!&D ;& ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' 's AAAc | j sct j d | j }| j 5 || _ d| _ d d d n # 1 swxY w Y | j ad S d S # t t f$ r Y d S w xY w)Nr T)
r r r r r r r r
StopIterationEOFError)r# frames r r; zFrameCatcher.run s '
.
1
**,,Z . ."'DK)-D&. . . . . . . . . . . . . . . '
.
.
.
.
. x( DD s4 ;A. A A. A A. A
A. .BBN)r r r r r r r r; r r r ry ry sZ
' ' '
r ry c g }d}| D ]`}| d rGt | | dd d }|r7| d r"|dd }| |dg |r| d r| d d d dd }t j d
r|
d d }n|
d d
}||d d< Rd|v rd}Zd|v rd}bg }|D ]L\ }}||vr| | |r| | 7| | M|S )z4Parse the output of the ffmpeg -list-devices commandFz[dshow]r+ "r, zalternative namez name r &z^&z\&z
video devicesTdevices)
splitlinesr7 loggerdebugsplitstripappendrt r5 r6 ri )
ffmpeg_output device_namesin_video_devicesline
friendly_namealt_name
device_names2s r r= r= s L ((** ) ) ??8 $ $ ) LL ::c1%%a(..00D
)DOOC$8$8
) $QrT
##]B$78888!
)djjll&=&=>P&Q&Q
) ::h2215;;==adC<**511 < ' / /T : :HH ' / /U ; ;H'/ R $$ D((#' d""#( M#/ 0 0
x
- - / / / /
0 * * * * / / / / r )NF)r r r5 r loggingr6 r
subprocessr: r numpyr] corer r getLoggerr r r7 r9 r r r r ry r= r r r r s B BH
( ( ( ( ( ( ( ( 8 $ $ <5!! &JJ\ W%% & JJ\ X&& & JJ%J + + + X' X' X' X' X'6 X' X' X'v) ) ) ) )9# ) ) )X" " " " "r