Skip to content

Commit ab0fcee

Browse files
schmidt-sebastiancopybara-github
schmidt-sebastian
authored and
copybara-github
committed
Retain error messages in MpImage
PiperOrigin-RevId: 843816907
1 parent bdad92c commit ab0fcee

File tree

8 files changed

+278
-163
lines changed

8 files changed

+278
-163
lines changed

‎mediapipe/tasks/c/test/test_utils.cc‎

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -44,11 +44,13 @@ MpImagePtr CreateCategoryMaskFromImage(const Image& image) {
4444
const uint8_t* pixel_data = image_frame->PixelData();
4545

4646
MpImagePtr mp_image;
47+
char* error_msg = nullptr;
4748
MpStatus status = MpImageCreateFromUint8Data(
4849
MpImageFormat::kMpImageFormatGray8, image_frame->Width(),
49-
image_frame->Height(), pixel_data, pixel_data_size, &mp_image);
50+
image_frame->Height(), pixel_data, pixel_data_size, &mp_image,
51+
&error_msg);
5052
if (status != kMpOk) {
51-
ABSL_LOG(ERROR) << "Failed to create MP Image: " << status;
53+
ABSL_LOG(ERROR) << "Failed to create MP Image: " << error_msg;
5254
return nullptr;
5355
}
5456
return mp_image;
@@ -70,9 +72,9 @@ float SimilarToUint8Mask(MpImageInternal* actual_mask,
7072
MpImageGetWidth(actual_mask) * MpImageGetHeight(actual_mask);
7173

7274
const uint8_t* buffer_actual;
73-
MpImageDataUint8(actual_mask, &buffer_actual);
75+
MpImageDataUint8(actual_mask, &buffer_actual, /*error_msg=*/nullptr);
7476
const uint8_t* buffer_expected;
75-
MpImageDataUint8(expected_mask, &buffer_expected);
77+
MpImageDataUint8(expected_mask, &buffer_expected, /*error_msg=*/nullptr);
7678

7779
for (int i = 0; i < total_pixels; ++i) {
7880
// Apply magnification factor and compare

‎mediapipe/tasks/c/vision/core/image.cc‎

Lines changed: 77 additions & 69 deletions
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ namespace {
3737
using ::mediapipe::Image;
3838
using ::mediapipe::ImageFormat;
3939
using ::mediapipe::ImageFrame;
40-
using ::mediapipe::tasks::c::core::ToMpStatus;
40+
using ::mediapipe::tasks::c::core::HandleStatus;
4141
using ::mediapipe::tasks::vision::core::GetCachedContiguousDataAttr;
4242
using ::mediapipe::tasks::vision::core::GetValue;
4343

@@ -197,76 +197,75 @@ absl::Status CreateMpImageInternal(MpImageFormat format, int width, int height,
197197

198198
extern "C" {
199199

200-
MP_EXPORT MpStatus MpImageCreateFromUint8Data(MpImageFormat format, int width,
201-
int height,
202-
const uint8_t* pixel_data,
203-
int pixel_data_size,
204-
MpImagePtr* out) {
200+
MP_EXPORT MpStatus MpImageCreateFromUint8Data(
201+
MpImageFormat format, int width, int height, const uint8_t* pixel_data,
202+
int pixel_data_size, MpImagePtr* out, char** error_msg) {
205203
if (!pixel_data) {
206-
ABSL_LOG(ERROR) << "Pixel data is null";
207-
return kMpInvalidArgument;
204+
return HandleStatus(absl::InvalidArgumentError("Pixel data is null"),
205+
error_msg);
208206
}
209207

210208
if (format != kMpImageFormatGray8 && format != kMpImageFormatSrgb &&
211209
format != kMpImageFormatSrgba) {
212-
ABSL_LOG(ERROR) << "Unsupported image format: " << ToString(format)
213-
<< " (expected GRAY8, SRGB, or SRGBA for uint8_t data)";
214-
return kMpInvalidArgument;
210+
return HandleStatus(
211+
absl::InvalidArgumentError(absl::StrFormat(
212+
"Unsupported image format: %s (expected GRAY8, SRGB, or "
213+
"SRGBA for uint8_t data)",
214+
ToString(format))),
215+
error_msg);
215216
}
216217

217218
auto status = CreateMpImageInternal(format, width, height, pixel_data,
218219
pixel_data_size, out);
219-
return ToMpStatus(status);
220+
return HandleStatus(status, error_msg);
220221
}
221222

222-
MP_EXPORT MpStatus MpImageCreateFromUint16Data(MpImageFormat format, int width,
223-
int height,
224-
const uint16_t* pixel_data,
225-
int pixel_data_size,
226-
MpImagePtr* out) {
223+
MP_EXPORT MpStatus MpImageCreateFromUint16Data(
224+
MpImageFormat format, int width, int height, const uint16_t* pixel_data,
225+
int pixel_data_size, MpImagePtr* out, char** error_msg) {
227226
if (!pixel_data) {
228-
ABSL_LOG(ERROR) << "Pixel data is null";
229-
return kMpInvalidArgument;
227+
return HandleStatus(absl::InvalidArgumentError("Pixel data is null"),
228+
error_msg);
230229
}
231230

232231
if (format != kMpImageFormatGray16 && format != kMpImageFormatSrgb48 &&
233232
format != kMpImageFormatSrgba64) {
234-
ABSL_LOG(ERROR)
235-
<< "Unsupported image format: " << ToString(format)
236-
<< " (expected GRAY16, SRGB48, or SRGBA64 for uint16_t data)";
237-
return kMpInvalidArgument;
233+
return HandleStatus(absl::InvalidArgumentError(absl::StrFormat(
234+
"Unsupported image format: %s (expected GRAY16, "
235+
"SRGB48, or SRGBA64 for uint16_t data)",
236+
ToString(format))),
237+
error_msg);
238238
}
239239

240240
auto status = CreateMpImageInternal(format, width, height, pixel_data,
241241
pixel_data_size * sizeof(uint16_t), out);
242-
return ToMpStatus(status);
242+
return HandleStatus(status, error_msg);
243243
}
244244

245-
MP_EXPORT MpStatus MpImageCreateFromFloatData(MpImageFormat format, int width,
246-
int height,
247-
const float* pixel_data,
248-
int pixel_data_size,
249-
MpImagePtr* out) {
245+
MP_EXPORT MpStatus MpImageCreateFromFloatData(
246+
MpImageFormat format, int width, int height, const float* pixel_data,
247+
int pixel_data_size, MpImagePtr* out, char** error_msg) {
250248
if (!pixel_data) {
251-
ABSL_LOG(ERROR) << "Pixel data is null";
252-
return kMpInvalidArgument;
249+
return HandleStatus(absl::InvalidArgumentError("Pixel data is null"),
250+
error_msg);
253251
}
254252

255253
if (format != kMpImageFormatVec32F1 && format != kMpImageFormatVec32F2 &&
256254
format != kMpImageFormatVec32F4) {
257-
ABSL_LOG(ERROR)
258-
<< "Unsupported image format: " << ToString(format)
259-
<< " (expected VEC32F1, VEC32F2, or VEC32F4 for float data)";
260-
return kMpInvalidArgument;
255+
return HandleStatus(absl::InvalidArgumentError(absl::StrFormat(
256+
"Unsupported image format: %s (expected VEC32F1, "
257+
"VEC32F2, or VEC32F4 for float data)",
258+
ToString(format))),
259+
error_msg);
261260
}
262261

263262
auto status = CreateMpImageInternal(format, width, height, pixel_data,
264263
pixel_data_size * sizeof(float), out);
265-
return ToMpStatus(status);
264+
return HandleStatus(status, error_msg);
266265
}
267266

268-
MP_EXPORT MpStatus MpImageCreateFromFile(const char* file_name,
269-
MpImagePtr* out) {
267+
MP_EXPORT MpStatus MpImageCreateFromFile(const char* file_name, MpImagePtr* out,
268+
char** error_msg) {
270269
unsigned char* image_data = nullptr;
271270
int width = 0;
272271
int height = 0;
@@ -287,15 +286,14 @@ MP_EXPORT MpStatus MpImageCreateFromFile(const char* file_name,
287286
/*desired_channels=*/0);
288287
#endif // TARGET_OS_OSX && !MEDIAPIPE_DISABLE_GPU
289288
if (image_data == nullptr) {
290-
ABSL_LOG(ERROR) << "Failed to load image from file: " << file_name;
291-
return kMpInternal;
289+
return HandleStatus(absl::InternalError("Failed to load image from file"),
290+
error_msg);
292291
}
293292

294293
auto format = GetImageFormatFromChannels(channels);
295294
if (!format.ok()) {
296-
ABSL_LOG(ERROR) << "Unsupported image format: " << format.status();
297295
stbi_image_free(image_data);
298-
return kMpInvalidArgument;
296+
return HandleStatus(format.status(), error_msg);
299297
}
300298

301299
auto image = std::make_shared<ImageFrame>(
@@ -308,7 +306,8 @@ MP_EXPORT MpStatus MpImageCreateFromFile(const char* file_name,
308306
}
309307

310308
MP_EXPORT MpStatus MpImageCreateFromImageFrame(MpImagePtr image,
311-
MpImagePtr* out) {
309+
MpImagePtr* out,
310+
char** error_ms) {
312311
auto mp_image = std::make_unique<MpImageInternal>();
313312
mp_image->image = Image(image->image.GetImageFrameSharedPtr());
314313
*out = mp_image.release();
@@ -356,97 +355,106 @@ MP_EXPORT MpImageFormat MpImageGetFormat(const MpImagePtr image) {
356355
return ToCImageFormat(GetImageFrameSharedPtr(image)->Format());
357356
}
358357

359-
MP_EXPORT MpStatus MpImageDataUint8(const MpImagePtr image,
360-
const uint8_t** out) {
358+
MP_EXPORT MpStatus MpImageDataUint8(const MpImagePtr image, const uint8_t** out,
359+
char** error_msg) {
361360
auto data = GetCachedContiguousDataAttr<uint8_t>(image);
362361
if (data.ok()) {
363362
*out = *data;
364363
}
365-
return ToMpStatus(data.status());
364+
return HandleStatus(data.status(), error_msg);
366365
}
367366

368367
MP_EXPORT MpStatus MpImageDataUint16(const MpImagePtr image,
369-
const uint16_t** out) {
368+
const uint16_t** out, char** error_msg) {
370369
auto data = GetCachedContiguousDataAttr<uint16_t>(image);
371370
if (data.ok()) {
372371
*out = *data;
373372
}
374-
return ToMpStatus(data.status());
373+
return HandleStatus(data.status(), error_msg);
375374
}
376375

377-
MP_EXPORT MpStatus MpImageDataFloat32(const MpImagePtr image,
378-
const float** out) {
376+
MP_EXPORT MpStatus MpImageDataFloat32(MpImagePtr image, const float** out,
377+
char** error_msg) {
379378
auto data = GetCachedContiguousDataAttr<float>(image);
380379
if (data.ok()) {
381380
*out = *data;
382381
}
383-
return ToMpStatus(data.status());
382+
return HandleStatus(data.status(), error_msg);
384383
}
385384

386385
MP_EXPORT MpStatus MpImageGetValueUint8(const MpImagePtr image, int* pos,
387-
int pos_size, uint8_t* out) {
386+
int pos_size, uint8_t* out,
387+
char** error_msg) {
388388
auto status = ValidateDimensions(image, pos_size);
389389
if (!status.ok()) {
390-
return ToMpStatus(status);
390+
return HandleStatus(status, error_msg);
391391
}
392392

393393
size_t byte_depth = GetImageFrameSharedPtr(image)->ByteDepth();
394394
if (byte_depth != 1) {
395-
ABSL_LOG(ERROR) << "Unexpected image byte depth: " << byte_depth
396-
<< " (expected 1 for uint8_t data)";
397-
return kMpInvalidArgument;
395+
return HandleStatus(absl::InvalidArgumentError(absl::StrFormat(
396+
"Unexpected image byte depth: %d (expected 1 for "
397+
"uint8_t data)",
398+
byte_depth)),
399+
error_msg);
398400
}
399401

400402
std::vector<int> pos_vec(pos, pos + pos_size);
401403
auto value = GetValue<uint8_t>(image, pos_vec);
402404
if (value.ok()) {
403405
*out = *value;
404406
}
405-
return ToMpStatus(value.status());
407+
return HandleStatus(value.status(), error_msg);
406408
}
407409

408410
MP_EXPORT MpStatus MpImageGetValueUint16(const MpImagePtr image, int* pos,
409-
int pos_size, uint16_t* out) {
411+
int pos_size, uint16_t* out,
412+
char** error_msg) {
410413
auto status = ValidateDimensions(image, pos_size);
411414
if (!status.ok()) {
412-
return ToMpStatus(status);
415+
return HandleStatus(status, error_msg);
413416
}
414417

415418
size_t byte_depth = GetImageFrameSharedPtr(image)->ByteDepth();
416419
if (byte_depth != 2) {
417-
ABSL_LOG(ERROR) << "Unexpected image byte depth: " << byte_depth
418-
<< " (expected 2 for uint16_t data)";
419-
return kMpInvalidArgument;
420+
return HandleStatus(absl::InvalidArgumentError(absl::StrFormat(
421+
"Unexpected image byte depth: %d (expected 2 for "
422+
"uint16_t data)",
423+
byte_depth)),
424+
error_msg);
420425
}
421426

422427
std::vector<int> pos_vec(pos, pos + pos_size);
423428
auto value = GetValue<uint16_t>(image, pos_vec);
424429
if (value.ok()) {
425430
*out = *value;
426431
}
427-
return ToMpStatus(value.status());
432+
return HandleStatus(value.status(), error_msg);
428433
}
429434

430435
MP_EXPORT MpStatus MpImageGetValueFloat32(const MpImagePtr image, int* pos,
431-
int pos_size, float* out) {
436+
int pos_size, float* out,
437+
char** error_msg) {
432438
auto status = ValidateDimensions(image, pos_size);
433439
if (!status.ok()) {
434-
return ToMpStatus(status);
440+
return HandleStatus(status, error_msg);
435441
}
436442

437443
size_t byte_depth = GetImageFrameSharedPtr(image)->ByteDepth();
438444
if (byte_depth != 4) {
439-
ABSL_LOG(ERROR) << "Unexpected image byte depth: " << byte_depth
440-
<< " (expected 4 for float data)";
441-
return kMpInvalidArgument;
445+
return HandleStatus(absl::InvalidArgumentError(absl::StrFormat(
446+
"Unexpected image byte depth: %d (expected 4 for "
447+
"float data)",
448+
byte_depth)),
449+
error_msg);
442450
}
443451

444452
std::vector<int> pos_vec(pos, pos + pos_size);
445453
auto value = GetValue<float>(image, pos_vec);
446454
if (value.ok()) {
447455
*out = *value;
448456
}
449-
return ToMpStatus(value.status());
457+
return HandleStatus(value.status(), error_msg);
450458
}
451459

452460
MP_EXPORT void MpImageFree(MpImagePtr image) { delete image; }

0 commit comments

Comments
 (0)