a PSicXB@sddlZddlZddlZddlmZddlmZmZmZm Z m Z m Z m Z m Z mZddlZddlmZmZmZmZddlmZe dZejfeeee edd d Zdejeeeejd d d ZGdddZeedddZGdddZdS)NFraction) AnyDictListOptionalCallableUnionTupleTypeVarcast)_probe_video_from_file_read_video_from_file read_videoread_video_timestamps)tqdmT)pts timebase_from timebase_to round_funcreturncCst|d||}||S)zconvert pts between different time bases Args: pts: presentation timestamp, float timebase_from: original timebase. Fraction timebase_to: new timebase. Fraction round_func: rounding function. rr)rrrrnew_ptsr\/var/www/html/django/DPS/env/lib/python3.9/site-packages/torchvision/datasets/video_utils.py pts_convertsr)tensorsizestepdilationrcCs|dkrtd||d}|}||||f}|||dd|d|f}|ddkrtd|f}t|||S)a similar to tensor.unfold, but with the dilation and specialized for 1d tensors Returns all consecutive windows of `size` elements, with `step` between windows. The distance between each element in a window is given by `dilation`. rz*tensor should have 1 dimension instead of r)dim ValueErrorstridenumeltorch as_strided)rrrr Zo_strider$Z new_stridenew_sizerrrunfold s    r(c@sReZdZdZeeddddZedddZee eee e fd d d Z dS) _VideoTimestampsDatasetz Dataset used to parallelize the reading of the timestamps of a list of videos, given their paths in the filesystem. Used in VideoClips and defined at top level so it can be pickled when forking. N) video_pathsrcCs ||_dSNr*)selfr*rrr__init__=sz _VideoTimestampsDataset.__init__rcCs t|jSr+lenr*r-rrr__len__@sz_VideoTimestampsDataset.__len__idxrcCst|j|Sr+)rr*)r-r5rrr __getitem__Csz#_VideoTimestampsDataset.__getitem__) __name__ __module__ __qualname____doc__rstrr.intr3r rfloatr6rrrrr)4sr))xrcCs|S)zH Dummy collate function to be used with _VideoTimestampsDataset r)r>rrr _collate_fnGsr?c@seZdZdZd.eeeeeeeeee feeeeeeeedddd Z dd d d Z eee fdd ddZ e eee fd ddZeeddddZed/ejeeeeeeejeeeejffdddZd0eeeeddddZed ddZed ddZed dd Zeeeefd!d"d#Zeeeeeeejfd$d%d&Zeeejejeee fefd!d'd(Zeee fd d)d*Zeee fdd+d,d-ZdS)1 VideoClipsaC Given a list of video files, computes all consecutive subvideos of size `clip_length_in_frames`, where the distance between each subvideo in the same video is defined by `frames_between_clips`. If `frame_rate` is specified, it will also resample all the videos to have the same frame rate, and the clips will refer to this frame rate. Creating this instance the first time is time-consuming, as it needs to decode all the videos in `video_paths`. It is recommended that you cache the results after instantiation of the class. Recreating the clips for different clip lengths is fast, and can be done with the `compute_clips` method. Args: video_paths (List[str]): paths to the video files clip_length_in_frames (int): size of a clip in number of frames frames_between_clips (int): step (in frames) between each clip frame_rate (int, optional): if specified, it will resample the video so that it has `frame_rate`, and then the clips will be defined on the resampled video num_workers (int): how many subprocesses to use for data loading. 0 means that the data will be loaded in the main process. (default: 0) output_format (str): The format of the output video tensors. Can be either "THWC" (default) or "TCHW". rNrTHWC)r*clip_length_in_framesframes_between_clips frame_rate_precomputed_metadata num_workers _video_width _video_height_video_min_dimension_video_max_dimension_audio_samples_audio_channels output_formatrcCs||_||_||_||_| |_| |_| |_| |_| |_ |j dvrTt d| d|durf| n | || |||dS)N)rBTCHWz5output_format should be either 'THWC' or 'TCHW', got .)r*rGrHrIrJrKrLrMupperrNr"_compute_frame_pts_init_from_metadata compute_clips)r-r*rCrDrErFrGrHrIrJrKrLrMrNrrrr.is    zVideoClips.__init__r/csg|_g|_ddljjjt|jd|jt d}t t |d^}|D]H}| dt t|\}}fdd|D}|j||j|qFWdn1s0YdS)NrrA) batch_sizerG collate_fn)totalrcsg|]}j|jdqS)dtype) as_tensorlong).0cr%rr z1VideoClips._compute_frame_pts..) video_pts video_fpstorch.utils.datautilsdata DataLoaderr)r*rGr?rr1updatelistzipextend)r-dlpbarbatchclipsfpsrr^rrRs   zVideoClips._compute_frame_pts)metadatarcCsV|d|_t|jt|dks$J|d|_t|jt|dksHJ|d|_dS)Nr*rarb)r*r1rarb)r-rprrrrSs   zVideoClips._init_from_metadatacCs|j|j|jd}|S)Nr*rarbrq)r- _metadatarrrrps zVideoClips.metadata)indicesrcszfdd|D}fdd|D}fdd|D}|||d}t|jjj|jjjjjj j d S)Ncsg|]}j|qSrr,r\ir2rrr_r`z%VideoClips.subset..csg|]}j|qSr)rartr2rrr_r`csg|]}j|qSr)rbrtr2rrr_r`rq)rFrGrHrIrJrKrLrM) type num_framesrrErGrHrIrJrKrLrM)r-rsr*rarbrprr2rsubsets*zVideoClips.subset)rarwrrorErc Cs|dur d}|dur|}t|t||}ttt|||}||}t|||}|sjt dt |t r|gt|}n t|||}||fS)NrzThere aren't enough frames in the current video to get a clip for the given clip length and frames between clips. The video (and potentially others) will be skipped.) r1r=r@_resample_video_idxr<mathfloorr(r$warningswarn isinstanceslice) rarwrrorEZ total_framesZ_idxsrnidxsrrrcompute_clips_for_videos    z"VideoClips.compute_clips_for_video)rwrrErc Cs||_||_||_g|_g|_t|j|jD]6\}}||||||\}}|j ||j |q,t dd|jD}| d |_dS)a Compute all consecutive sequences of clips from video_pts. Always returns clips of size `num_frames`, meaning that the last few frames in a video can potentially be dropped. Args: num_frames (int): number of frames for the clip step (int): distance between two clips frame_rate (int, optional): The frame rate cSsg|] }t|qSrr1r\vrrrr_r`z,VideoClips.compute_clips..rN)rwrrErnresampling_idxsrirarbrappendr%rZcumsumtolistcumulative_sizes) r-rwrrErarornrZ clip_lengthsrrrrTs  zVideoClips.compute_clipscCs|Sr+) num_clipsr2rrrr3szVideoClips.__len__cCs t|jSr+r0r2rrr num_videosszVideoClips.num_videoscCs |jdS)zJ Number of subclips that are available in the video list. )rr2rrrrszVideoClips.num_clipsr4cCs6t|j|}|dkr|}n||j|d}||fS)zw Converts a flattened representation of the indices into a video_idx, clip_idx representation. rr)bisect bisect_rightr)r-r5 video_idxclip_idxrrrget_clip_location s zVideoClips.get_clip_location)rw original_fpsnew_fpsrcCsPt||}|r(t|}tdd|Stj|tjd|}|tj }|S)NrX) r= is_integerr<rr%arangefloat32r{toint64)rwrrrrrrrrys  zVideoClips._resample_video_idxc Cst||kr&td|d|d||\}}|j|}|j||}ddlm}|}|dkr|jdkrxtd|j dkrtd|j dkrtd |j dkrtd |j dkrtd |dkr|d }|d  } t||| \} } } nt|} | j}d }tt|d }tt|d  }d\}}tdd}t| jj| jj}| jrt| jj| jj}t|||tj}t|||tj}| j}t||j|j |j |j ||f||j |j||f|d \} } }d|i} |d ur|| d<|j d ur&|j!||}t"|t#j$r||d}| |} |j | d<t%| |j&ksLJ| j'd|j&|j(dkrh| )dddd} | | | |fS)a7 Gets a subclip from a list of videos. Args: idx (int): index of the subclip. Must be between 0 and num_clips(). Returns: video (Tensor) audio (Tensor) info (Dict) video_idx (int): index of the video in `video_paths` zIndex z out of range (z number of clips)r)get_video_backendpyavz.pyav backend doesn't support _video_width != 0z/pyav backend doesn't support _video_height != 0z6pyav backend doesn't support _video_min_dimension != 0z6pyav backend doesn't support _video_max_dimension != 0z0pyav backend doesn't support _audio_samples != 0rN)rrr) video_width video_heightvideo_min_dimensionvideo_max_dimensionvideo_pts_rangevideo_timebase audio_samplesaudio_channelsaudio_pts_rangeaudio_timebaserb audio_fpsz x rO)*r IndexErrorrr*rn torchvisionrrHr"rIrJrKrLitemrr rbr r<rr numerator denominator has_audiorrrzr{ceilaudio_sample_raterrMrErr~r%Tensorr1rwshaperNpermute)r-r5rr video_pathZclip_ptsrbackend start_ptsend_ptsvideoaudioinfo_inforbrZvideo_start_ptsZ video_end_ptsZaudio_start_ptsZ audio_end_ptsrr_Zresampling_idxrrrget_clip%sz                & zVideoClips.get_clipcCsndd|jD}dd|jD}|r6t|}|}|j}||d<||d<|d=|d=|d=d |d <|S) NcSsg|] }t|qSrrrrrrr_~r`z+VideoClips.__getstate__..cSsg|]}|tjqSr)rr%r)r\r>rrrr_r`video_pts_sizesrarnrrr_version)rar%catnumpy__dict__copy)r-rradrrr __getstate__}s  zVideoClips.__getstate__)rrcCsfd|vr||_dStj|dtjd}tj||ddd}|d=||d<||_||j|j|jdS)NrrarXrr)r!) rr%rZrsplitrTrwrrE)r-rrarrr __setstate__szVideoClips.__setstate__) rArNNrrrrrrrrB)N)N) r7r8r9r:rr;r<rrrr.rRrSpropertyrprx staticmethodr%rr r rrrTr3rrrryrrrrrrrr@Nsd %  (Xr@)r) rrzr| fractionsrtypingrrrrrr r r r r%torchvision.ior rrrrdrrr{r<rrr(r)r?r@rrrrs ,