diff options
Diffstat (limited to 'chromium/extensions/browser/api')
3 files changed, 169 insertions, 1 deletions
diff --git a/chromium/extensions/browser/api/media_perception_private/conversion_utils.cc b/chromium/extensions/browser/api/media_perception_private/conversion_utils.cc index 8ea457ea397..f8849a4b051 100644 --- a/chromium/extensions/browser/api/media_perception_private/conversion_utils.cc +++ b/chromium/extensions/browser/api/media_perception_private/conversion_utils.cc @@ -77,6 +77,8 @@ EntityType EntityTypeProtoToIdl(const mri::Entity& entity) { return ENTITY_TYPE_PERSON; case mri::Entity::MOTION_REGION: return ENTITY_TYPE_MOTION_REGION; + case mri::Entity::LABELED_REGION: + return ENTITY_TYPE_LABELED_REGION; case mri::Entity::UNSPECIFIED: return ENTITY_TYPE_UNSPECIFIED; } @@ -100,9 +102,29 @@ Entity EntityProtoToIdl(const mri::Entity& entity) { if (entity.has_depth()) entity_result.depth = DistanceProtoToIdl(entity.depth()); + if (entity.has_label()) + entity_result.entity_label = std::make_unique<std::string>(entity.label()); + return entity_result; } +PacketLatency PacketLatencyProtoToIdl( + const mri::PacketLatency& packet_latency) { + PacketLatency packet_latency_result; + + if (packet_latency.has_label()) { + packet_latency_result.packet_label = + std::make_unique<std::string>(packet_latency.label()); + } + + if (packet_latency.has_latency_usec()) { + packet_latency_result.latency_usec = + std::make_unique<int>(packet_latency.latency_usec()); + } + + return packet_latency_result; +} + FramePerception FramePerceptionProtoToIdl( const mri::FramePerception& frame_perception) { FramePerception frame_perception_result; @@ -127,6 +149,14 @@ FramePerception FramePerceptionProtoToIdl( for (const auto& entity : frame_perception.entity()) frame_perception_result.entities->emplace_back(EntityProtoToIdl(entity)); } + if (frame_perception.packet_latency_size() > 0) { + frame_perception_result.packet_latency = + std::make_unique<std::vector<PacketLatency>>(); + for (const auto& packet_latency : frame_perception.packet_latency()) { + frame_perception_result.packet_latency->emplace_back( + PacketLatencyProtoToIdl(packet_latency)); + } + } return frame_perception_result; } @@ -223,6 +253,24 @@ mri::State::Status StateStatusIdlToProto(const State& state) { return mri::State::STATUS_UNSPECIFIED; } +void VideoStreamParamIdlToProto(mri::VideoStreamParam* param_result, + const VideoStreamParam& param) { + if (param_result == nullptr) + return; + + if (param.id) + param_result->set_id(*param.id); + + if (param.width) + param_result->set_width(*param.width); + + if (param.height) + param_result->set_height(*param.height); + + if (param.frame_rate) + param_result->set_frame_rate(*param.frame_rate); +} + } // namespace State StateProtoToIdl(const mri::State& state) { @@ -243,6 +291,15 @@ mri::State StateIdlToProto(const State& state) { if (state.device_context) state_result.set_device_context(*state.device_context); + if (state.video_stream_param && state.video_stream_param.get() != nullptr) { + for (size_t i = 0; i < state.video_stream_param.get()->size(); ++i) { + mri::VideoStreamParam* video_stream_param_result = + state_result.add_video_stream_param(); + VideoStreamParamIdlToProto(video_stream_param_result, + state.video_stream_param.get()->at(i)); + } + } + return state_result; } diff --git a/chromium/extensions/browser/api/media_perception_private/conversion_utils_unittest.cc b/chromium/extensions/browser/api/media_perception_private/conversion_utils_unittest.cc index 5bf994a3b65..9230cf1d891 100644 --- a/chromium/extensions/browser/api/media_perception_private/conversion_utils_unittest.cc +++ b/chromium/extensions/browser/api/media_perception_private/conversion_utils_unittest.cc @@ -15,6 +15,29 @@ namespace extensions { namespace { const char kTestDeviceContext[] = "Video camera"; +const char kFakePacketLabel1[] = "Packet1"; +const char kFakePacketLabel3[] = "Packet3"; +const char kFakeEntityLabel3[] = "Region3"; +const char kVideoStreamIdForFaceDetection[] = "FaceDetection"; +const char kVideoStreamIdForVideoCapture[] = "VideoCapture"; + +const int kVideoStreamWidthForFaceDetection = 1280; +const int kVideoStreamHeightForFaceDetection = 720; +const int kVideoStreamFrameRateForFaceDetection = 30; +const int kVideoStreamWidthForVideoCapture = 640; +const int kVideoStreamHeightForVideoCapture = 360; +const int kVideoStreamFrameRateForVideoCapture = 5; + +void InitializeVideoStreamParam(media_perception::VideoStreamParam& param, + const std::string& id, + int width, + int height, + int frame_rate) { + param.id = std::make_unique<std::string>(id); + param.width = std::make_unique<int>(width); + param.height = std::make_unique<int>(height); + param.frame_rate = std::make_unique<int>(frame_rate); +} void InitializeFakeFramePerception(const int index, mri::FramePerception* frame_perception) { @@ -23,6 +46,20 @@ void InitializeFakeFramePerception(const int index, frame_perception->set_frame_height_in_px(4); frame_perception->set_timestamp(5); + // Add a couple fake packet latency to the frame perception. + mri::PacketLatency* packet_latency_one = + frame_perception->add_packet_latency(); + packet_latency_one->set_label(kFakePacketLabel1); + packet_latency_one->set_latency_usec(10011); + + mri::PacketLatency* packet_latency_two = + frame_perception->add_packet_latency(); + packet_latency_two->set_latency_usec(20011); + + mri::PacketLatency* packet_latency_three = + frame_perception->add_packet_latency(); + packet_latency_three->set_label(kFakePacketLabel3); + // Add a couple fake entities to the frame perception. Note: PERSON // EntityType is currently unused. mri::Entity* entity_one = frame_perception->add_entity(); @@ -50,6 +87,10 @@ void InitializeFakeFramePerception(const int index, bounding_box_two->mutable_top_left()->set_x(14); bounding_box_two->mutable_top_left()->set_y(15); bounding_box_two->set_normalized(true); + + mri::Entity* entity_three = frame_perception->add_entity(); + entity_three->set_type(mri::Entity::LABELED_REGION); + entity_three->set_label(kFakeEntityLabel3); } void ValidateFramePerceptionResult( @@ -64,7 +105,25 @@ void ValidateFramePerceptionResult( ASSERT_TRUE(frame_perception_result.timestamp); EXPECT_EQ(*frame_perception_result.timestamp, 5); - ASSERT_EQ(2u, frame_perception_result.entities->size()); + // Validate packet latency. + ASSERT_EQ(3u, frame_perception_result.packet_latency->size()); + const media_perception::PacketLatency& packet_latency_one = + frame_perception_result.packet_latency->at(0); + EXPECT_EQ(*packet_latency_one.packet_label, kFakePacketLabel1); + EXPECT_EQ(*packet_latency_one.latency_usec, 10011); + + const media_perception::PacketLatency& packet_latency_two = + frame_perception_result.packet_latency->at(1); + EXPECT_FALSE(packet_latency_two.packet_label); + EXPECT_EQ(*packet_latency_two.latency_usec, 20011); + + const media_perception::PacketLatency& packet_latency_three = + frame_perception_result.packet_latency->at(2); + EXPECT_EQ(*packet_latency_three.packet_label, kFakePacketLabel3); + EXPECT_FALSE(packet_latency_three.latency_usec); + + // Validate entities. + ASSERT_EQ(3u, frame_perception_result.entities->size()); const media_perception::Entity& entity_result_one = frame_perception_result.entities->at(0); ASSERT_TRUE(entity_result_one.id); @@ -111,6 +170,13 @@ void ValidateFramePerceptionResult( EXPECT_EQ(*bounding_box_result_two->top_left->y, 15); EXPECT_FALSE(bounding_box_result_two->bottom_right); EXPECT_TRUE(*bounding_box_result_two->normalized); + + const media_perception::Entity& entity_result_three = + frame_perception_result.entities->at(2); + ASSERT_TRUE(entity_result_three.entity_label); + EXPECT_EQ(*entity_result_three.entity_label, kFakeEntityLabel3); + EXPECT_EQ(entity_result_three.type, + media_perception::ENTITY_TYPE_LABELED_REGION); } void InitializeFakeImageFrameData(mri::ImageFrame* image_frame) { @@ -226,4 +292,41 @@ TEST(MediaPerceptionConversionUtilsTest, StateIdlToProto) { EXPECT_EQ(state_proto.status(), mri::State::RESTARTING); } +TEST(MediaPerceptionConversionUtilsTest, StateIdlToProtoWithVideoStreamParam) { + media_perception::State state; + state.status = media_perception::STATUS_RUNNING; + state.video_stream_param.reset( + new std::vector<media_perception::VideoStreamParam>(2)); + InitializeVideoStreamParam( + state.video_stream_param.get()->at(0), kVideoStreamIdForFaceDetection, + kVideoStreamWidthForFaceDetection, kVideoStreamHeightForFaceDetection, + kVideoStreamFrameRateForFaceDetection); + + InitializeVideoStreamParam( + state.video_stream_param.get()->at(1), kVideoStreamIdForVideoCapture, + kVideoStreamWidthForVideoCapture, kVideoStreamHeightForVideoCapture, + kVideoStreamFrameRateForVideoCapture); + + mri::State state_proto = StateIdlToProto(state); + EXPECT_EQ(state_proto.status(), mri::State::RUNNING); + + EXPECT_EQ(kVideoStreamIdForFaceDetection, + state_proto.video_stream_param(0).id()); + EXPECT_EQ(kVideoStreamWidthForFaceDetection, + state_proto.video_stream_param(0).width()); + EXPECT_EQ(kVideoStreamHeightForFaceDetection, + state_proto.video_stream_param(0).height()); + EXPECT_EQ(kVideoStreamFrameRateForFaceDetection, + state_proto.video_stream_param(0).frame_rate()); + + EXPECT_EQ(kVideoStreamIdForVideoCapture, + state_proto.video_stream_param(1).id()); + EXPECT_EQ(kVideoStreamWidthForVideoCapture, + state_proto.video_stream_param(1).width()); + EXPECT_EQ(kVideoStreamHeightForVideoCapture, + state_proto.video_stream_param(1).height()); + EXPECT_EQ(kVideoStreamFrameRateForVideoCapture, + state_proto.video_stream_param(1).frame_rate()); +} + } // namespace extensions diff --git a/chromium/extensions/browser/api/media_perception_private/media_perception_private_api.cc b/chromium/extensions/browser/api/media_perception_private/media_perception_private_api.cc index 4e5e07e6ff5..10f562fe1f8 100644 --- a/chromium/extensions/browser/api/media_perception_private/media_perception_private_api.cc +++ b/chromium/extensions/browser/api/media_perception_private/media_perception_private_api.cc @@ -52,6 +52,14 @@ MediaPerceptionPrivateSetStateFunction::Run() { return RespondNow( Error("Only provide deviceContext with SetState RUNNING.")); } + + // Check that video stream parameters are only provided with SetState RUNNING. + if (params->state.status != media_perception::STATUS_RUNNING && + params->state.video_stream_param.get() != nullptr) { + return RespondNow( + Error("SetState: status must be RUNNING to set videoStreamParam.")); + } + MediaPerceptionAPIManager* manager = MediaPerceptionAPIManager::Get(browser_context()); manager->SetState( |