ڧg-NddlZddlZddlmZmZmZddlZddlmZddl m Z e rde fdZ nde fd Z ddl Z e je jjee jjjd s ed Z n#e$red Z YnwxYwGd dZdS)N)AnyDictIterator)_log_api_usage_once)_HAS_CPU_VIDEO_DECODERreturncdS)NTr W/var/www/html/ai-engine/env/lib/python3.11/site-packages/torchvision/io/video_reader.py_has_video_optrstr cdS)NFr r r rrrsur pict_typea+Your version of PyAV is too old for the necessary video operations in torchvision. If you are on Python 3.5, you will have to build from source (the conda-forge packages are not up-to-date). See https://github.com/mikeboers/PyAV#installation for instructions on how to install PyAV on your system. zPyAV is not installed, and is necessary for the video operations in torchvision. See https://github.com/mikeboers/PyAV#installation for instructions on how to install PyAV on your system. c eZdZdZ ddedededdfd Zdeeeffd Z de eeeffd Z dd e de ddfdZdeeeffdZdede fdZdS) VideoReadera Fine-grained video-reading API. Supports frame-by-frame reading of various streams from a single video container. Much like previous video_reader API it supports the following backends: video_reader, pyav, and cuda. Backends can be set via `torchvision.set_video_backend` function. .. warning:: In the near future, we intend to centralize PyTorch's video decoding capabilities within the `torchcodec `_ project. We encourage you to try it out and share your feedback, as the torchvision video decoders will eventually be deprecated. .. betastatus:: VideoReader class Example: The following examples creates a :mod:`VideoReader` object, seeks into 2s point, and returns a single frame:: import torchvision video_path = "path_to_a_test_video" reader = torchvision.io.VideoReader(video_path, "video") reader.seek(2.0) frame = next(reader) :mod:`VideoReader` implements the iterable API, which makes it suitable to using it in conjunction with :mod:`itertools` for more advanced reading. As such, we can use a :mod:`VideoReader` instance inside for loops:: reader.seek(2) for frame in reader: frames.append(frame['data']) # additionally, `seek` implements a fluent API, so we can do for frame in reader.seek(2): frames.append(frame['data']) With :mod:`itertools`, we can read all frames between 2 and 5 seconds with the following code:: for frame in itertools.takewhile(lambda x: x['pts'] <= 5, reader.seek(2)): frames.append(frame['data']) and similarly, reading 10 frames after the 2s timestamp can be achieved as follows:: for frame in itertools.islice(reader.seek(2), 10): frames.append(frame['data']) .. note:: Each stream descriptor consists of two parts: stream type (e.g. 'video') and a unique stream id (which are determined by the video encoding). In this way, if the video container contains multiple streams of the same type, users can access the one they want. If only stream type is passed, the decoder auto-detects first stream of that type. Args: src (string, bytes object, or tensor): The media source. If string-type, it must be a file path supported by FFMPEG. If bytes, should be an in-memory representation of a file supported by FFMPEG. If Tensor, it is interpreted internally as byte buffer. It must be one-dimensional, of type ``torch.uint8``. stream (string, optional): descriptor of the required stream, followed by the stream id, in the format ``{stream_type}:{stream_id}``. Defaults to ``"video:0"``. Currently available options include ``['video', 'audio']`` num_threads (int, optional): number of threads used by the codec to decode video. Default value (0) enables multithreading with codec-dependent heuristic. The performance will depend on the version of FFMPEG codecs supported. videorsrcstream num_threadsr NcTt|ddlm}||_t |t r|st dnt |tr|jdvrtd|jdkrtj |}ntj 5tj dd tj|tj }dddn #1swxYwYnRt |tjr|jd vrtd nt d t%||jdkr@tjd}tjj|||_dS|jdkrt |t r-tjj||||_dSt |tjrItjjddd|_|j|||dSdS|jdkrt5j|d|_|dd}t=|ddkrdn't?|dd}||i|_ |jj!di|j |_dStd"|j)Nr)get_video_backendzsrc cannot be empty)cudazTVideoReader cannot be initialized from bytes object when using cuda or pyav backend.pyavignorez The given buffer is not writable)message)dtype)rrzUVideoReader cannot be initialized from Tensor object when using cuda or pyav backend.z7src must be either string, Tensor or bytes object. Got r video_readerr)metadata_errors:rzUnknown video backend: {}r )#rr rbackend isinstancestr ValueErrorbytes RuntimeErrorioBytesIOwarningscatch_warningsfilterwarningstorch frombufferuint8Tensortypedeviceclasses torchvision GPUDecoder_cVideoinit_from_memoryavopen containersplitlenint pyav_streamdecodeformat)selfrrrrr3 stream_type stream_ids r__init__zVideoReader.__init__zsf D!!!((((((((** c3   d 8 !6777 8 U # # d|x''"j''joo,..CC+H>`aaaa*3ekBBBCCCCCCCCCCCCCCCCU\ * * d|///"k0 bW[\_W`W`bbcc c <6 ! !\&))Fm/::3GGDGGG \^ + +#s## C-399#v{SSC.. C-399"b!DD((fkBBBBB C C\V # #WS(CCCDN ,,s++A.K c!2!233q88c&,,sBSBSTUBV>W>WI +Y7D +dn+??d.>??DGGG :AA$,OOPP Ps-7C00C47C4c|jdkr=|j}|dkrt|ddS|jdkr|j\}}n t|j}t |j|jz}d|jvrNtj |  ddd}nFd |jvr;tj |  dd}nd}n#tjj$rtwxYw|dkrt||dS) aDecodes and returns the next frame of the current stream. Frames are encoded as a dict with mandatory data and pts fields, where data is a tensor, and pts is a presentation timestamp of the frame expressed in seconds as a float. Returns: (dict): a dictionary and containing decoded frame (``data``) and corresponding timestamp (``pts``) in seconds rrN)dataptsrrrraudio)r#r7nextnumel StopIterationfloatrI time_baser@r. as_tensorto_rgb to_ndarraypermuter:errorEOFError)rCframerIs r__next__zVideoReader.__next__si <6 ! !GLLNNE{{}}!!##!$// / \^ + +JE33 $TW EI788d...!OELLNN,E,E,G,GHHPPQRTUWXYYEE 000!OE,<,<,>,>??GG1MMEE E8$ $ $ $## $ ;;==A   c***s 2C EEc|S)Nr )rCs r__iter__zVideoReader.__iter__s r Ftime_skeyframes_onlyc|jdvr|j||n|dkrd}|jjjdi|jd}tt||j z }|stj d|j|dd||jj di|j|_|S)aSeek within current stream. Args: time_s (float): seek time in seconds keyframes_only (bool): allow to seek only to keyframes .. note:: Current implementation is the so-called precise seek. This means following seek, call to :mod:`next()` will return the frame with the exact timestamp if it exists or the first frame with timestamp larger than ``time_s``. )rrrz1Accurate seek is not implemented for pyav backendTF)backward any_framerr ) r#r7seekr<streamsgetr@r?roundrOr+warnrA)rCrZr[temp_stroffsets rr_zVideoReader.seeks <3 3 3 GLL 0 0 0 0zz1t~-1EED4DEEaHHv(::;;<??DG r c|jdkri}|jjD]}|j|vr|jdkrd}nd}|gdgi||j<t |ddp|j}||jdt|j|j z||j|t||S|j S)zReturns video metadata Returns: (dict): dictionary containing duration and frame rate for every stream rrfps framerateduration average_rateN) r#r<r`r2getattr sample_rateappendrNrirOr7 get_metadata)rCmetadatarrate_nrates rrnzVideoReader.get_metadatas <6 ! !H.0 B B;h..{g--!&!,-3RR,HHV[)v~t<<R@R%j188vQWQa?a9b9bccc%f-44U4[[AAAAOw##%%%r c|jdkrtjd|jdkr|dd}t |ddkrdn't |dd}||i|_|jjdi|j|_ dS|j |S) aSet current stream. Explicitly define the stream we are operating on. Args: stream (string): descriptor of the required stream. Defaults to ``"video:0"`` Currently available stream types include ``['video', 'audio']``. Each descriptor consists of two parts: stream type (e.g. 'video') and a unique stream id (which are determined by video encoding). In this way, if the video container contains multiple streams of the same type, users can access the one they want. If only stream type is passed, the decoder auto-detects first stream of that type and returns it. Returns: (bool): True on success, False otherwise rz*GPU decoding only works with video stream.rr"rrTr ) r#r+rcr=r>r?r@r<rAr7set_current_stream)rCrrDrEs rrszVideoReader.set_current_stream s" <6 ! ! MF G G G <6 ! ! ,,s++A.K c!2!233q88c&,,sBSBSTUBV>W>WI +Y7D +dn+??d.>??DG4w))&111r )rr)F)__name__ __module__ __qualname____doc__r%r?rFrrrWrrYrNboolr_rnrsr r rrr/s1HHZ 7Q7Q 7Q7Q 7Q  7Q7Q7Q7Qr#+$sCx.#+#+#+#+J(4S>25$=6&d38n&&&&.22222222r r)r)r+typingrrrr.utilsr _video_optr rxrr:logging set_levelERRORhasattrrrV VideoFrame ImportErrorrr r rrss &&&&&&&&&& ''''''......D D IIIJ)*** 728>,k : :  [       BBBw2w2w2w2w2w2w2w2w2w2sABBB