Set preferred video formats for this driver. First formats from the list are better and will
be selected if available.
342901
public void setPreferredFormats(List<String> preferredFormats) {
		if (preferredFormats.isEmpty()) {
			throw new IllegalArgumentException("Preferred formats list must not be empty");
		}
		this.preferredFormats = new ArrayList<>(preferredFormats);
	}
373983
public void setVideoPosition(com.google.api.ads.admanager.axis.v201808.VideoPosition videoPosition) {
        this.videoPosition = videoPosition;
    }
366868
function VideoLoader(loadItem, preferXHR) {
		this.AbstractMediaLoader_constructor(loadItem, preferXHR, createjs.AbstractLoader.VIDEO);

		if (createjs.RequestUtils.isVideoTag(loadItem) || createjs.RequestUtils.isVideoTag(loadItem.src)) {
			this.setTag(createjs.RequestUtils.isVideoTag(loadItem)?loadItem:loadItem.src);

			// We can't use XHR for a tag that's passed in.
			this._preferXHR = false;
		} else {
			this.setTag(this._createTag());
		}
	}
33131
def libvlc_video_set_aspect_ratio(p_mi, psz_aspect):
    '''
    '''
    f = _Cfunctions.get('libvlc_video_set_aspect_ratio', None) or \
        _Cfunction('libvlc_video_set_aspect_ratio', ((1,), (1,),), None,
                    None, MediaPlayer, ctypes.c_char_p)
    return f(p_mi, psz_aspect)
203303
def available_formats():
    
    loaders = mesh_formats()
    loaders.extend(path_formats())
    loaders.extend(compressed_loaders.keys())

    return loaders
238286
def wrap(self, video_mode):
        
        size, bits, self.refresh_rate = video_mode
        self.width, self.height = size
        self.red_bits, self.green_bits, self.blue_bits = bits
258567
private VideoFormat getSizedVideoFormat(Dimension size) {

		Format[] formats = device.getFormats();
		VideoFormat format = null;

		for (Format f : formats) {

			if (!"RGB".equalsIgnoreCase(f.getEncoding()) || !(f instanceof VideoFormat)) {
				continue;
			}

			Dimension d = ((VideoFormat) f).getSize();
			if (d.width == size.width && d.height == size.height) {
				format = (VideoFormat) f;
				break;
			}
		}

		return format;
	}
325009
def setMovie( self, movie ):
        
        self._movieLabel.setMovie(movie)
        self._smallMovieLabel.setMovie(movie)
47503
def video(query, opts = {})
      invoke 'Video',
        query,
        opts,
        passthrough_opts: %i(filters sort),
        enum_opt_to_module: {filters: VideoFilter, sort: VideoSort},
        param_name_replacements: {filters: 'VideoFilters', sort: 'VideoSortBy'}
    end
1052729
private void sortLists(){
		//sort RGBformats
		//if native RGB24 is supported, put it first
		moveToFirstIfNative(RGBformats, V4L4JConstants.IMF_RGB24);
		
		//sort BGRformats
		//if native BGR24 is supported, put it first
		moveToFirstIfNative(BGRformats, V4L4JConstants.IMF_BGR24);
		
		//sort YUV420formats
		//if native YUV420 is supported, put it first
		moveToFirstIfNative(YUV420formats, V4L4JConstants.IMF_YUV420);
		
		//sort YVU420formats
		//if native YVU420 is supported, put it first
		moveToFirstIfNative(YVU420formats, V4L4JConstants.IMF_YVU420);
		
		//sort JPEGformats
		//put native formats first and libvideo converted ones next
		moveNativeFirst(JPEGformats);
		//if native RGB32 is supported, put it first
		moveToFirstIfNative(JPEGformats, V4L4JConstants.IMF_RGB32);
		//if native RGB24 is supported, put it first
		moveToFirstIfNative(JPEGformats, V4L4JConstants.IMF_RGB24);
		//if native UYVY is supported, put it first
		moveToFirstIfNative(JPEGformats, V4L4JConstants.IMF_UYVY);
		//if native YUYV is supported, put it first
		moveToFirstIfNative(JPEGformats, V4L4JConstants.IMF_YUYV);
		//if native YUV420P is supported, put it first
		moveToFirstIfNative(JPEGformats, V4L4JConstants.IMF_YUV420);
		//if native MJPEG is supported, put it first
		moveToFirstIfNative(JPEGformats, V4L4JConstants.IMF_MJPEG);
		//if native JPEG is supported, put it first
		moveToFirstIfNative(JPEGformats, V4L4JConstants.IMF_JPEG);
	}
823870
async def set_codec(self, codectype=0x0040, bitrate=0x0003):
        """"""
        act = self.service.action("X_SetCodec")
        res = await act.async_call(CodecType=codectype, CodecBitrate=bitrate)
        return res
1305532
def set_backbuffer(self, preferred_backbuffer_size, flags=0):
        """"""
        if not (isinstance(preferred_backbuffer_size, Vector2)):
            raise ValueError("preferred_backbuffer_size must be of type Vector2")

        self.__backbuffer = pygame.display.set_mode(preferred_backbuffer_size, flags)
        self.Camera.world_center = preferred_backbuffer_size / 2.0
572286
public void open(int width, int height, double frameRate) throws JavaAVException {
		if (!open.get()) {
			String input = "video=" + device;

			demuxer = new Demuxer();
			demuxer.setInputFormat(format);
			demuxer.setImageWidth(width);
			demuxer.setImageHeight(height);
			demuxer.setFramerate(frameRate);
			demuxer.open(input);

			open.set(true);
		}
	}
253699
public function setVideo($video)
	{
		if (is_string($video)) {
			$this->video = $video;
		} else if (is_resource($video)) {
			$this->addMultipart("video", $video);
			$this->video = "attach://video";
		} else if ($video instanceof InputFile) {
			$this->addMultipart("video", $video->getFile());
			$this->video = "attach://video";
		}
	}
902320
protected void setPreferredPixelsPerTile(ClientPreferredPixelsPerTile ppt) {
		switch (ppt.getPreferredPixelsPerTileType()) {
			case MAP:
				preferredTileSize = layer.getMapModel().getMapView().getWidth() * 
					layer.getMapModel().getMapView().getHeight();
				break;
			case CONFIGURED:
				preferredTileSize = ppt.getWidth() * ppt.getHeight();
				break;
		}
	}
405213
def libvlc_video_set_spu(p_mi, i_spu):
    '''
    '''
    f = _Cfunctions.get('libvlc_video_set_spu', None) or \
        _Cfunction('libvlc_video_set_spu', ((1,), (1,),), None,
                    ctypes.c_int, MediaPlayer, ctypes.c_int)
    return f(p_mi, i_spu)
745419
def set_encoding_format(self, encoding_format):
    """"""
    supported = ENCODE_FN.keys()
    if encoding_format not in supported:
      raise ValueError('`encoding_format` must be one of %s.' % supported)
    self._encoding_format = encoding_format