def __init__(self, hass, camera): """Initialize.""" super().__init__() self._camera = camera self._name = camera._friendly_name self._state = camera._state self._ssid = camera._ssid self._local_ip = camera._ip self._ssid = camera._ssid self._device_mac = camera._device_mac self._device_model = camera._device_model self._username = "******" self._password = "******" self.is_streaming = False self._ffmpeg = hass.data[DATA_FFMPEG] self._ffmpeg_arguments = DEFAULT_FFMPEG_ARGUMENTS self._ffmpeg_arguments_image = DEFAULT_FFMPEG_ARGUMENTS_IMAGE self._ffmpeg_image_frame = ImageFrame(self._ffmpeg.binary, loop=hass.loop) self._ffmpeg_stream = CameraMjpeg(self._ffmpeg.binary, loop=hass.loop) self._last_image = None self._last_image_url = None self._local_rtsp_port = camera._local_rtsp_port self._stream_url = f"rtsp://{self._username}:{self._password}@{self._local_ip}:{self._local_rtsp_port}/live" self.access_tokens = self.update_tokens()
async def async_camera_image(self): """Return a frame from the camera stream.""" ffmpeg = ImageFrame(self._ffmpeg.binary, loop=self.hass.loop) image = await asyncio.shield( ffmpeg.get_image(self._rtsp_stream, output_format=IMAGE_JPEG)) return image
async def async_camera_image(self): ffmpeg = ImageFrame(self._ffmpeg.binary) streaming_url = self.getStreamSource() image = await asyncio.shield( ffmpeg.get_image(streaming_url, output_format=IMAGE_JPEG,) ) return image
async def async_camera_image(self): """Return a still image response from the camera.""" image = None if self.device.capabilities.snapshot: try: image = await self.device.device.get_snapshot( self.profile.token, self._basic_auth) except ONVIFError as err: LOGGER.error( "Fetch snapshot image failed from %s, falling back to FFmpeg; %s", self.device.name, err, ) if image is None: ffmpeg = ImageFrame(self.hass.data[DATA_FFMPEG].binary) image = await asyncio.shield( ffmpeg.get_image( self._stream_uri, output_format=IMAGE_JPEG, extra_cmd=self.device.config_entry.options.get( CONF_EXTRA_ARGUMENTS), )) return image
async def async_camera_image(self): """Return a still image response from the camera.""" from haffmpeg.tools import ImageFrame, IMAGE_JPEG ffmpeg = ImageFrame(self._manager.binary, loop=self.hass.loop) image = await asyncio.shield(ffmpeg.get_image( self._input, output_format=IMAGE_JPEG, extra_cmd=self._extra_arguments), loop=self.hass.loop) return image
async def async_camera_image(self, width=None, height=None): ffmpeg = ImageFrame(self._ffmpeg.binary) streaming_url = self.getStreamSource() image = await asyncio.shield( ffmpeg.get_image( streaming_url, output_format=IMAGE_JPEG, extra_cmd=self._extra_arguments, )) return image
async def isRtspStreamWorking(hass, host, username, password): _ffmpeg = hass.data[DATA_FFMPEG] ffmpeg = ImageFrame(_ffmpeg.binary) username = urllib.parse.quote_plus(username) password = urllib.parse.quote_plus(password) streaming_url = f"rtsp://{username}:{password}@{host}:554/stream1" image = await asyncio.shield( ffmpeg.get_image(streaming_url, output_format=IMAGE_JPEG,) ) return not image == b""
async def async_camera_image(self): """Return a still image response from the camera.""" #self._hass.async_create_task(async_reader_job(self._named_pipe, self._reader)) from haffmpeg.tools import ImageFrame, IMAGE_JPEG ffmpeg = ImageFrame(self._ffmpeg_manager.binary, loop=self.hass.loop) image = await asyncio.shield( ffmpeg.get_image(self._named_pipe, output_format=IMAGE_JPEG)) return image
async def async_camera_image(self): """Return a still image response from the camera.""" self.renew_live_stream_session() from haffmpeg.tools import ImageFrame, IMAGE_JPEG ffmpeg = ImageFrame(self._ffmpeg.binary, loop=self.hass.loop) image = await asyncio.shield(ffmpeg.get_image( self._live_stream_session.live_stream_url, output_format=IMAGE_JPEG, extra_cmd=self._ffmpeg_arguments)) return image
async def async_camera_image(self): """Return a frame from the camera stream.""" ffmpeg = ImageFrame(self._ffmpeg.binary) image = await asyncio.shield( ffmpeg.get_image( self._rtsp_stream, output_format=IMAGE_JPEG, extra_cmd=self._ffmpeg_arguments, )) return image
async def async_camera_image(self): """Return a still image response from the camera.""" self.renew_live_stream_session() from haffmpeg.tools import ImageFrame, IMAGE_JPEG ffmpeg = ImageFrame(self._ffmpeg.binary, loop=self.hass.loop) image = await asyncio.shield(ffmpeg.get_image( self._live_stream_session.live_stream_url, output_format=IMAGE_JPEG, extra_cmd=self._ffmpeg_arguments), loop=self.hass.loop) return image
async def async_camera_image(self): url = await self.stream_source() if url: ffmpeg = ImageFrame(self._manager.binary) self._last_image = await asyncio.shield( ffmpeg.get_image( url, output_format=IMAGE_JPEG, extra_cmd=self._extra_arguments, timeout=60, )) return self._last_image
async def async_camera_image(self): """Return a still image response from the camera.""" await self.hass.async_add_executor_job(self.renew_live_stream_session) ffmpeg = ImageFrame(self._ffmpeg.binary, loop=self.hass.loop) image = await asyncio.shield( ffmpeg.get_image( self._live_stream_session.live_stream_url, output_format=IMAGE_JPEG, extra_cmd=self._ffmpeg_arguments, )) return image
async def async_camera_image(self): """Return a still image response from the camera.""" from haffmpeg.tools import ImageFrame, IMAGE_JPEG url = await self.hass.async_add_job(self.get_latest_video_url) if url != self._last_url: ffmpeg = ImageFrame(self._manager.binary, loop=self.hass.loop) self._last_image = await asyncio.shield(ffmpeg.get_image( url, output_format=IMAGE_JPEG, extra_cmd=self._extra_arguments), loop=self.hass.loop) self._last_url = url return self._last_image
async def async_camera_image(self): """Return a still image response from the camera.""" from haffmpeg.tools import ImageFrame, IMAGE_JPEG _LOGGER.debug("Retrieving image from camera '%s'", self._name) ffmpeg = ImageFrame( self.hass.data[DATA_FFMPEG].binary, loop=self.hass.loop) image = await asyncio.shield(ffmpeg.get_image( self._input, output_format=IMAGE_JPEG, extra_cmd=self._ffmpeg_arguments), loop=self.hass.loop) return image
async def async_camera_image(self): """Return a still image response from the camera.""" url = await self._get_latest_video_url() if url and url != self._last_url: ffmpeg = ImageFrame(self._manager.binary) self._last_image = await asyncio.shield( ffmpeg.get_image( url, output_format=IMAGE_JPEG, extra_cmd=self._extra_arguments ), ) self._last_url = url return self._last_image
def __init__(self, ffmpeg, device, coordinator): """Initialize.""" super().__init__(device, coordinator) Camera.__init__(self) self._async_unsub_dispatcher_connect = None self._ffmpeg = ffmpeg self._ffmpeg_arguments = DEFAULT_FFMPEG_ARGUMENTS self._ffmpeg_image_frame = ImageFrame(ffmpeg.binary) self._ffmpeg_stream = CameraMjpeg(ffmpeg.binary) self._last_image = None self._last_image_url = None self._stream_url = None
def cli(ffmpeg, source, format_img, output, extra): """FFMPEG capture frame as image.""" loop = asyncio.get_event_loop() stream = ImageFrame(ffmpeg_bin=ffmpeg, loop=loop) future = asyncio.ensure_future( stream.get_image(input_source=source, output_format=format_img, extra_cmd=extra) ) image = loop.run_until_complete(future) if image is not None: with open(output, "wb") as fh_img: fh_img.write(image)
async def async_get_image( hass: HomeAssistant, input_source: str, output_format: str = IMAGE_JPEG, extra_cmd: str | None = None, ) -> bytes | None: """Get an image from a frame of an RTSP stream.""" manager = hass.data[DATA_FFMPEG] ffmpeg = ImageFrame(manager.binary) image = await asyncio.shield( ffmpeg.get_image(input_source, output_format=output_format, extra_cmd=extra_cmd) ) return image
def __init__(self, hass, camera): """Initialize.""" super().__init__() self._async_unsub_dispatcher_connect = None self._camera = camera self._ffmpeg = hass.data[DATA_FFMPEG] self._ffmpeg_arguments = DEFAULT_FFMPEG_ARGUMENTS self._ffmpeg_image_frame = ImageFrame(self._ffmpeg.binary) self._ffmpeg_stream = CameraMjpeg(self._ffmpeg.binary) self._last_image = None self._last_image_url = None self._stream_url = None
async def async_camera_image(self): """Return a still image response from the camera.""" from haffmpeg.tools import ImageFrame, IMAGE_JPEG ffmpeg = ImageFrame(self._ffmpeg.binary, loop=self.hass.loop) if self._video_url is None: return image = await asyncio.shield( ffmpeg.get_image(self._video_url, output_format=IMAGE_JPEG, extra_cmd=self._ffmpeg_arguments)) return image
async def async_camera_image(self): """Return a still image response from the camera.""" _LOGGER.debug("Retrieving image from camera '%s'", self._name) ffmpeg = ImageFrame(self.hass.data[DATA_FFMPEG].binary, loop=self.hass.loop) image = await asyncio.shield( ffmpeg.get_image( self._input, output_format=IMAGE_JPEG, extra_cmd=self._ffmpeg_arguments ) ) return image
async def async_camera_image(self): """Return a still image response from the camera.""" ffmpeg = ImageFrame(self._ffmpeg.binary) if self._video_url is None: return image = await asyncio.shield( ffmpeg.get_image( self._video_url, output_format=IMAGE_JPEG, )) return image
def cli(ffmpeg, source, format_img, output, extra): """FFMPEG capture frame as image.""" loop = asyncio.get_event_loop() stream = ImageFrame(ffmpeg_bin=ffmpeg, loop=loop) future = asyncio.ensure_future( stream.get_image(input_source=source, output_format=format_img, extra_cmd=extra)) image = loop.run_until_complete(future) if image is not None: with open(output, "wb") as fh_img: fh_img.write(image)
async def async_camera_image(self): """Return a still image response from the camera.""" from haffmpeg.tools import ImageFrame, IMAGE_JPEG url = await self.hass.async_add_job(self.get_latest_video_url) if url != self._last_url: ffmpeg = ImageFrame(self._manager.binary, loop=self.hass.loop) self._last_image = await asyncio.shield( ffmpeg.get_image(url, output_format=IMAGE_JPEG, extra_cmd=self._extra_arguments)) self._last_url = url return self._last_image
async def async_camera_image(self) -> bytes | None: """Return a still image response from the camera.""" await self.opp.async_add_executor_job(self.renew_live_stream_session) live_stream_url = await self.opp.async_add_executor_job( getattr, self._live_stream_session, "live_stream_url") ffmpeg = ImageFrame(self._ffmpeg.binary) image: bytes | None = await asyncio.shield( ffmpeg.get_image( live_stream_url, output_format=IMAGE_JPEG, extra_cmd=self._ffmpeg_arguments, )) return image
async def async_get_image( opp: OpenPeerPower, input_source: str, output_format: str = IMAGE_JPEG, extra_cmd: str | None = None, ): """Get an image from a frame of an RTSP stream.""" manager = opp.data[DATA_FFMPEG] ffmpeg = ImageFrame(manager.binary) image = await asyncio.shield( ffmpeg.get_image(input_source, output_format=output_format, extra_cmd=extra_cmd)) return image
async def async_camera_image(self): """Return bytes of camera image.""" _LOGGER.debug("Handling image from camera %s", self.device.name) stream_uri = await self.stream_source() ffmpeg = ImageFrame(self.hass.data[DATA_FFMPEG].binary, loop=self.hass.loop) image = await asyncio.shield( ffmpeg.get_image( stream_uri, output_format=IMAGE_JPEG, extra_cmd=self.device.config_entry.options.get( CONF_EXTRA_ARGUMENTS), )) return image
async def async_camera_image(self): """Return a still image response from the camera.""" from haffmpeg.tools import ImageFrame, IMAGE_JPEG if not self._input: await self.hass.async_add_executor_job(self.obtain_input_uri) if not self._input: return None ffmpeg = ImageFrame( self.hass.data[DATA_FFMPEG].binary, loop=self.hass.loop) image = await asyncio.shield(ffmpeg.get_image( self._input, output_format=IMAGE_JPEG, extra_cmd=self._ffmpeg_arguments), loop=self.hass.loop) return image
async def async_camera_image(self): """Return a still image response from the camera.""" image = None if self.device.capabilities.snapshot: if self._snapshot_uri is None: self._snapshot_uri = await self.device.async_get_snapshot_uri( self.profile) auth = None if self.device.username and self.device.password: auth = HTTPDigestAuth(self.device.username, self.device.password) def fetch(): """Read image from a URL.""" try: response = requests.get(self._snapshot_uri, timeout=5, auth=auth) if response.status_code < 300: return response.content except requests.exceptions.RequestException as error: LOGGER.error( "Fetch snapshot image failed from %s, falling back to FFmpeg; %s", self.device.name, error, ) return None image = await self.hass.async_add_executor_job(fetch) if image is None: ffmpeg = ImageFrame(self.hass.data[DATA_FFMPEG].binary, loop=self.hass.loop) image = await asyncio.shield( ffmpeg.get_image( self._stream_uri, output_format=IMAGE_JPEG, extra_cmd=self.device.config_entry.options.get( CONF_EXTRA_ARGUMENTS), )) return image
async def async_camera_image(self, width: int | None = None, height: int | None = None) -> bytes | None: """Return a still image response from the camera.""" """Ignore width and height when the image is fetched from url.""" """Camera component will resize it.""" image = None if self._still_image_url: auth = None if self._user or self._password: auth = HTTPBasicAuth(self._user, self._password) def fetch(): """Read image from a URL.""" try: response = requests.get(self._still_image_url, timeout=HTTP_TIMEOUT, auth=auth) if response.status_code < 300: return response.content except requests.exceptions.RequestException as error: _LOGGER.error( "Fetch snapshot image failed from %s, falling back to FFmpeg; %s", self._name, error, ) return None image = await self.hass.async_add_executor_job(fetch) if image is None: stream_source = await self.stream_source() if stream_source: ffmpeg = ImageFrame(self.hass.data[DATA_FFMPEG].binary) image = await asyncio.shield( ffmpeg.get_image(stream_source, output_format=IMAGE_JPEG, extra_cmd=self._extra_arguments, width=width, height=height)) return image
async def async_camera_image(self): """Return a still image response from the camera.""" _LOGGER.debug("Retrieving image from camera '%s'", self._name) image = None if self._snapshot is not None: auth = None if self._username and self._password: auth = HTTPDigestAuth(self._username, self._password) def fetch(): """Read image from a URL.""" try: response = requests.get(self._snapshot, timeout=5, auth=auth) if response.status_code < 300: return response.content except requests.exceptions.RequestException as error: _LOGGER.error( "Fetch snapshot image failed from %s, falling back to FFmpeg; %s", self._name, error, ) return None image = await self.hass.async_add_job(fetch) if image is None: # Don't keep trying the snapshot URL self._snapshot = None ffmpeg = ImageFrame(self.hass.data[DATA_FFMPEG].binary, loop=self.hass.loop) image = await asyncio.shield( ffmpeg.get_image( self._input, output_format=IMAGE_JPEG, extra_cmd=self._ffmpeg_arguments, )) return image
async def async_camera_image(self): """Return a still image response from the camera.""" try: host = self.host.async_render() except TemplateError as exc: _LOGGER.error("Error parsing template %s: %s", self.host, exc) return self._last_image url = await self.hass.async_add_executor_job(self.get_latest_video_url, host) if url != self._last_url: ffmpeg = ImageFrame(self._manager.binary, loop=self.hass.loop) self._last_image = await asyncio.shield( ffmpeg.get_image(url, output_format=IMAGE_JPEG, extra_cmd=self._extra_arguments)) self._last_url = url return self._last_image
async def async_get_image( hass: HomeAssistant, input_source: str, output_format: str = IMAGE_JPEG, extra_cmd: str | None = None, width: int | None = None, height: int | None = None, ) -> bytes | None: """Get an image from a frame of an RTSP stream.""" manager = hass.data[DATA_FFMPEG] ffmpeg = ImageFrame(manager.binary) if width and height and (extra_cmd is None or "-s" not in extra_cmd): size_cmd = f"-s {width}x{height}" if extra_cmd is None: extra_cmd = size_cmd else: extra_cmd += " " + size_cmd image = await asyncio.shield( ffmpeg.get_image(input_source, output_format=output_format, extra_cmd=extra_cmd) ) return image