Switch to returning specific error codes or DNN_GENERIC_ERROR when an error is encountered. For OpenVINO API errors, currently DNN_GENERIC_ERROR is returned.
Showing the changes to libavfilter (3 of 3 files). Show all
Unified · Split
| @@ -112,7 +112,7 @@ static int get_datatype_size(DNNDataType dt) · 111 unmodified lines | ||
| 112 | 112 | } |
| 113 | 113 | } |
| 114 | 114 | |
| 115 | −static DNNReturnType fill_model_input_ov(OVModel *ov_model, OVRequestItem *request) | |
| 115 | +static int fill_model_input_ov(OVModel *ov_model, OVRequestItem *request) | |
| 116 | 116 | { |
| 117 | 117 | dimensions_t dims; |
| 118 | 118 | precision_e precision; |
| @@ -131,7 +131,7 @@ static DNNReturnType fill_model_input_ov(OVModel *ov_model, OVRequestItem *reque · 12 unmodified lines | ||
| 131 | 131 | status = ie_infer_request_get_blob(request->infer_request, task->input_name, &input_blob); |
| 132 | 132 | if (status != OK) { |
| 133 | 133 | av_log(ctx, AV_LOG_ERROR, "Failed to get input blob with name %s\n", task->input_name); |
| 134 | − return DNN_ERROR; | |
| 134 | + return DNN_GENERIC_ERROR; | |
| 135 | 135 | } |
| 136 | 136 | |
| 137 | 137 | status |= ie_blob_get_dims(input_blob, &dims); |
| @@ -139,14 +139,14 @@ static DNNReturnType fill_model_input_ov(OVModel *ov_model, OVRequestItem *reque · 1 unmodified line | ||
| 139 | 139 | if (status != OK) { |
| 140 | 140 | ie_blob_free(&input_blob); |
| 141 | 141 | av_log(ctx, AV_LOG_ERROR, "Failed to get input blob dims/precision\n"); |
| 142 | − return DNN_ERROR; | |
| 142 | + return DNN_GENERIC_ERROR; | |
| 143 | 143 | } |
| 144 | 144 | |
| 145 | 145 | status = ie_blob_get_buffer(input_blob, &blob_buffer); |
| 146 | 146 | if (status != OK) { |
| 147 | 147 | ie_blob_free(&input_blob); |
| 148 | 148 | av_log(ctx, AV_LOG_ERROR, "Failed to get input blob buffer\n"); |
| 149 | − return DNN_ERROR; | |
| 149 | + return DNN_GENERIC_ERROR; | |
| 150 | 150 | } |
| 151 | 151 | |
| 152 | 152 | input.height = dims.dims[2]; |
| @@ -301,8 +301,9 @@ static void infer_completion_callback(void *args) · 148 unmodified lines | ||
| 301 | 301 | } |
| 302 | 302 | } |
| 303 | 303 | |
| 304 | −static DNNReturnType init_model_ov(OVModel *ov_model, const char *input_name, const char *output_name) | |
| 304 | +static int init_model_ov(OVModel *ov_model, const char *input_name, const char *output_name) | |
| 305 | 305 | { |
| 306 | + int ret = DNN_SUCCESS; | |
| 306 | 307 | OVContext *ctx = &ov_model->ctx; |
| 307 | 308 | IEStatusCode status; |
| 308 | 309 | ie_available_devices_t a_dev; |
| @@ -317,14 +318,18 @@ static DNNReturnType init_model_ov(OVModel *ov_model, const char *input_name, co · 8 unmodified lines | ||
| 317 | 318 | if (ctx->options.batch_size > 1) { |
| 318 | 319 | input_shapes_t input_shapes; |
| 319 | 320 | status = ie_network_get_input_shapes(ov_model->network, &input_shapes); |
| 320 | − if (status != OK) | |
| 321 | + if (status != OK) { | |
| 322 | + ret = DNN_GENERIC_ERROR; | |
| 321 | 323 | goto err; |
| 324 | + } | |
| 322 | 325 | for (int i = 0; i < input_shapes.shape_num; i++) |
| 323 | 326 | input_shapes.shapes[i].shape.dims[0] = ctx->options.batch_size; |
| 324 | 327 | status = ie_network_reshape(ov_model->network, input_shapes); |
| 325 | 328 | ie_network_input_shapes_free(&input_shapes); |
| 326 | − if (status != OK) | |
| 329 | + if (status != OK) { | |
| 330 | + ret = DNN_GENERIC_ERROR; | |
| 327 | 331 | goto err; |
| 332 | + } | |
| 328 | 333 | } |
| 329 | 334 | |
| 330 | 335 | // The order of dims in the openvino is fixed and it is always NCHW for 4-D data. |
| @@ -332,11 +337,13 @@ static DNNReturnType init_model_ov(OVModel *ov_model, const char *input_name, co · 1 unmodified line | ||
| 332 | 337 | status = ie_network_set_input_layout(ov_model->network, input_name, NHWC); |
| 333 | 338 | if (status != OK) { |
| 334 | 339 | av_log(ctx, AV_LOG_ERROR, "Failed to set layout as NHWC for input %s\n", input_name); |
| 340 | + ret = DNN_GENERIC_ERROR; | |
| 335 | 341 | goto err; |
| 336 | 342 | } |
| 337 | 343 | status = ie_network_set_output_layout(ov_model->network, output_name, NHWC); |
| 338 | 344 | if (status != OK) { |
| 339 | 345 | av_log(ctx, AV_LOG_ERROR, "Failed to set layout as NHWC for output %s\n", output_name); |
| 346 | + ret = DNN_GENERIC_ERROR; | |
| 340 | 347 | goto err; |
| 341 | 348 | } |
| 342 | 349 | |
| @@ -350,6 +357,7 @@ static DNNReturnType init_model_ov(OVModel *ov_model, const char *input_name, co · 7 unmodified lines | ||
| 350 | 357 | status = ie_network_set_input_precision(ov_model->network, input_name, U8); |
| 351 | 358 | if (status != OK) { |
| 352 | 359 | av_log(ctx, AV_LOG_ERROR, "Failed to set input precision as U8 for %s\n", input_name); |
| 360 | + ret = DNN_GENERIC_ERROR; | |
| 353 | 361 | goto err; |
| 354 | 362 | } |
| 355 | 363 | } |
| @@ -360,6 +368,7 @@ static DNNReturnType init_model_ov(OVModel *ov_model, const char *input_name, co · 4 unmodified lines | ||
| 360 | 368 | status = ie_core_get_available_devices(ov_model->core, &a_dev); |
| 361 | 369 | if (status != OK) { |
| 362 | 370 | av_log(ctx, AV_LOG_ERROR, "Failed to get available devices\n"); |
| 371 | + ret = DNN_GENERIC_ERROR; | |
| 363 | 372 | goto err; |
| 364 | 373 | } |
| 365 | 374 | for (int i = 0; i < a_dev.num_devices; i++) { |
| @@ -367,6 +376,7 @@ static DNNReturnType init_model_ov(OVModel *ov_model, const char *input_name, co · 1 unmodified line | ||
| 367 | 376 | } |
| 368 | 377 | av_log(ctx, AV_LOG_ERROR,"device %s may not be supported, all available devices are: \"%s\"\n", |
| 369 | 378 | ctx->options.device_type, all_dev_names); |
| 379 | + ret = AVERROR(ENODEV); | |
| 370 | 380 | goto err; |
| 371 | 381 | } |
| 372 | 382 | |
| @@ -378,12 +388,14 @@ static DNNReturnType init_model_ov(OVModel *ov_model, const char *input_name, co · 5 unmodified lines | ||
| 378 | 388 | |
| 379 | 389 | ov_model->request_queue = ff_safe_queue_create(); |
| 380 | 390 | if (!ov_model->request_queue) { |
| 391 | + ret = AVERROR(ENOMEM); | |
| 381 | 392 | goto err; |
| 382 | 393 | } |
| 383 | 394 | |
| 384 | 395 | for (int i = 0; i < ctx->options.nireq; i++) { |
| 385 | 396 | OVRequestItem *item = av_mallocz(sizeof(*item)); |
| 386 | 397 | if (!item) { |
| 398 | + ret = AVERROR(ENOMEM); | |
| 387 | 399 | goto err; |
| 388 | 400 | } |
| 389 | 401 | |
| @@ -391,16 +403,19 @@ static DNNReturnType init_model_ov(OVModel *ov_model, const char *input_name, co · 1 unmodified line | ||
| 391 | 403 | item->callback.args = item; |
| 392 | 404 | if (ff_safe_queue_push_back(ov_model->request_queue, item) < 0) { |
| 393 | 405 | av_freep(&item); |
| 406 | + ret = AVERROR(ENOMEM); | |
| 394 | 407 | goto err; |
| 395 | 408 | } |
| 396 | 409 | |
| 397 | 410 | status = ie_exec_network_create_infer_request(ov_model->exe_network, &item->infer_request); |
| 398 | 411 | if (status != OK) { |
| 412 | + ret = DNN_GENERIC_ERROR; | |
| 399 | 413 | goto err; |
| 400 | 414 | } |
| 401 | 415 | |
| 402 | 416 | item->lltasks = av_malloc_array(ctx->options.batch_size, sizeof(*item->lltasks)); |
| 403 | 417 | if (!item->lltasks) { |
| 418 | + ret = AVERROR(ENOMEM); | |
| 404 | 419 | goto err; |
| 405 | 420 | } |
| 406 | 421 | item->lltask_count = 0; |
| @@ -408,11 +423,13 @@ static DNNReturnType init_model_ov(OVModel *ov_model, const char *input_name, co · 1 unmodified line | ||
| 408 | 423 | |
| 409 | 424 | ov_model->task_queue = ff_queue_create(); |
| 410 | 425 | if (!ov_model->task_queue) { |
| 426 | + ret = AVERROR(ENOMEM); | |
| 411 | 427 | goto err; |
| 412 | 428 | } |
| 413 | 429 | |
| 414 | 430 | ov_model->lltask_queue = ff_queue_create(); |
| 415 | 431 | if (!ov_model->lltask_queue) { |
| 432 | + ret = AVERROR(ENOMEM); | |
| 416 | 433 | goto err; |
| 417 | 434 | } |
| 418 | 435 | |
| @@ -420,14 +437,14 @@ static DNNReturnType init_model_ov(OVModel *ov_model, const char *input_name, co · 1 unmodified line | ||
| 420 | 437 | |
| 421 | 438 | err: |
| 422 | 439 | ff_dnn_free_model_ov(&ov_model->model); |
| 423 | − return DNN_ERROR; | |
| 440 | + return ret; | |
| 424 | 441 | } |
| 425 | 442 | |
| 426 | −static DNNReturnType execute_model_ov(OVRequestItem *request, Queue *inferenceq) | |
| 443 | +static int execute_model_ov(OVRequestItem *request, Queue *inferenceq) | |
| 427 | 444 | { |
| 428 | 445 | IEStatusCode status; |
| 429 | − DNNReturnType ret; | |
| 430 | 446 | LastLevelTaskItem *lltask; |
| 447 | + int ret = DNN_SUCCESS; | |
| 431 | 448 | TaskItem *task; |
| 432 | 449 | OVContext *ctx; |
| 433 | 450 | OVModel *ov_model; |
| @@ -451,11 +468,13 @@ static DNNReturnType execute_model_ov(OVRequestItem *request, Queue *inferenceq) · 17 unmodified lines | ||
| 451 | 468 | status = ie_infer_set_completion_callback(request->infer_request, &request->callback); |
| 452 | 469 | if (status != OK) { |
| 453 | 470 | av_log(ctx, AV_LOG_ERROR, "Failed to set completion callback for inference\n"); |
| 471 | + ret = DNN_GENERIC_ERROR; | |
| 454 | 472 | goto err; |
| 455 | 473 | } |
| 456 | 474 | status = ie_infer_request_infer_async(request->infer_request); |
| 457 | 475 | if (status != OK) { |
| 458 | 476 | av_log(ctx, AV_LOG_ERROR, "Failed to start async inference\n"); |
| 477 | + ret = DNN_GENERIC_ERROR; | |
| 459 | 478 | goto err; |
| 460 | 479 | } |
| 461 | 480 | return DNN_SUCCESS; |
| @@ -467,20 +486,21 @@ static DNNReturnType execute_model_ov(OVRequestItem *request, Queue *inferenceq) · 5 unmodified lines | ||
| 467 | 486 | status = ie_infer_request_infer(request->infer_request); |
| 468 | 487 | if (status != OK) { |
| 469 | 488 | av_log(ctx, AV_LOG_ERROR, "Failed to start synchronous model inference\n"); |
| 489 | + ret = DNN_GENERIC_ERROR; | |
| 470 | 490 | goto err; |
| 471 | 491 | } |
| 472 | 492 | infer_completion_callback(request); |
| 473 | − return (task->inference_done == task->inference_todo) ? DNN_SUCCESS : DNN_ERROR; | |
| 493 | + return (task->inference_done == task->inference_todo) ? DNN_SUCCESS : DNN_GENERIC_ERROR; | |
| 474 | 494 | } |
| 475 | 495 | err: |
| 476 | 496 | if (ff_safe_queue_push_back(ov_model->request_queue, request) < 0) { |
| 477 | 497 | ie_infer_request_free(&request->infer_request); |
| 478 | 498 | av_freep(&request); |
| 479 | 499 | } |
| 480 | − return DNN_ERROR; | |
| 500 | + return ret; | |
| 481 | 501 | } |
| 482 | 502 | |
| 483 | −static DNNReturnType get_input_ov(void *model, DNNData *input, const char *input_name) | |
| 503 | +static int get_input_ov(void *model, DNNData *input, const char *input_name) | |
| 484 | 504 | { |
| 485 | 505 | OVModel *ov_model = model; |
| 486 | 506 | OVContext *ctx = &ov_model->ctx; |
| @@ -495,14 +515,14 @@ static DNNReturnType get_input_ov(void *model, DNNData *input, const char *input · 8 unmodified lines | ||
| 495 | 515 | status = ie_network_get_inputs_number(ov_model->network, &model_input_count); |
| 496 | 516 | if (status != OK) { |
| 497 | 517 | av_log(ctx, AV_LOG_ERROR, "Failed to get input count\n"); |
| 498 | − return DNN_ERROR; | |
| 518 | + return DNN_GENERIC_ERROR; | |
| 499 | 519 | } |
| 500 | 520 | |
| 501 | 521 | for (size_t i = 0; i < model_input_count; i++) { |
| 502 | 522 | status = ie_network_get_input_name(ov_model->network, i, &model_input_name); |
| 503 | 523 | if (status != OK) { |
| 504 | 524 | av_log(ctx, AV_LOG_ERROR, "Failed to get No.%d input's name\n", (int)i); |
| 505 | − return DNN_ERROR; | |
| 525 | + return DNN_GENERIC_ERROR; | |
| 506 | 526 | } |
| 507 | 527 | if (strcmp(model_input_name, input_name) == 0) { |
| 508 | 528 | ie_network_name_free(&model_input_name); |
| @@ -510,7 +530,7 @@ static DNNReturnType get_input_ov(void *model, DNNData *input, const char *input · 1 unmodified line | ||
| 510 | 530 | status |= ie_network_get_input_precision(ov_model->network, input_name, &precision); |
| 511 | 531 | if (status != OK) { |
| 512 | 532 | av_log(ctx, AV_LOG_ERROR, "Failed to get No.%d input's dims or precision\n", (int)i); |
| 513 | − return DNN_ERROR; | |
| 533 | + return DNN_GENERIC_ERROR; | |
| 514 | 534 | } |
| 515 | 535 | |
| 516 | 536 | input->channels = dims.dims[1]; |
| @@ -527,7 +547,7 @@ static DNNReturnType get_input_ov(void *model, DNNData *input, const char *input · 10 unmodified lines | ||
| 527 | 547 | } |
| 528 | 548 | |
| 529 | 549 | av_log(ctx, AV_LOG_ERROR, "Could not find \"%s\" in model, all input(s) are: \"%s\"\n", input_name, all_input_names); |
| 530 | − return DNN_ERROR; | |
| 550 | + return AVERROR(EINVAL); | |
| 531 | 551 | } |
| 532 | 552 | |
| 533 | 553 | static int contain_valid_detection_bbox(AVFrame *frame) |
| @@ -567,7 +587,7 @@ static int contain_valid_detection_bbox(AVFrame *frame) · 33 unmodified lines | ||
| 567 | 587 | return 1; |
| 568 | 588 | } |
| 569 | 589 | |
| 570 | −static DNNReturnType extract_lltask_from_task(DNNFunctionType func_type, TaskItem *task, Queue *lltask_queue, DNNExecBaseParams *exec_params) | |
| 590 | +static int extract_lltask_from_task(DNNFunctionType func_type, TaskItem *task, Queue *lltask_queue, DNNExecBaseParams *exec_params) | |
| 571 | 591 | { |
| 572 | 592 | switch (func_type) { |
| 573 | 593 | case DFT_PROCESS_FRAME: |
| @@ -575,14 +595,14 @@ static DNNReturnType extract_lltask_from_task(DNNFunctionType func_type, TaskIte · 1 unmodified line | ||
| 575 | 595 | { |
| 576 | 596 | LastLevelTaskItem *lltask = av_malloc(sizeof(*lltask)); |
| 577 | 597 | if (!lltask) { |
| 578 | − return DNN_ERROR; | |
| 598 | + return AVERROR(ENOMEM); | |
| 579 | 599 | } |
| 580 | 600 | task->inference_todo = 1; |
| 581 | 601 | task->inference_done = 0; |
| 582 | 602 | lltask->task = task; |
| 583 | 603 | if (ff_queue_push_back(lltask_queue, lltask) < 0) { |
| 584 | 604 | av_freep(&lltask); |
| 585 | − return DNN_ERROR; | |
| 605 | + return AVERROR(ENOMEM); | |
| 586 | 606 | } |
| 587 | 607 | return DNN_SUCCESS; |
| 588 | 608 | } |
| @@ -615,28 +635,28 @@ static DNNReturnType extract_lltask_from_task(DNNFunctionType func_type, TaskIte · 26 unmodified lines | ||
| 615 | 635 | |
| 616 | 636 | lltask = av_malloc(sizeof(*lltask)); |
| 617 | 637 | if (!lltask) { |
| 618 | − return DNN_ERROR; | |
| 638 | + return AVERROR(ENOMEM); | |
| 619 | 639 | } |
| 620 | 640 | task->inference_todo++; |
| 621 | 641 | lltask->task = task; |
| 622 | 642 | lltask->bbox_index = i; |
| 623 | 643 | if (ff_queue_push_back(lltask_queue, lltask) < 0) { |
| 624 | 644 | av_freep(&lltask); |
| 625 | − return DNN_ERROR; | |
| 645 | + return AVERROR(ENOMEM); | |
| 626 | 646 | } |
| 627 | 647 | } |
| 628 | 648 | return DNN_SUCCESS; |
| 629 | 649 | } |
| 630 | 650 | default: |
| 631 | 651 | av_assert0(!"should not reach here"); |
| 632 | − return DNN_ERROR; | |
| 652 | + return AVERROR(EINVAL); | |
| 633 | 653 | } |
| 634 | 654 | } |
| 635 | 655 | |
| 636 | −static DNNReturnType get_output_ov(void *model, const char *input_name, int input_width, int input_height, | |
| 656 | +static int get_output_ov(void *model, const char *input_name, int input_width, int input_height, | |
| 637 | 657 | const char *output_name, int *output_width, int *output_height) |
| 638 | 658 | { |
| 639 | − DNNReturnType ret; | |
| 659 | + int ret; | |
| 640 | 660 | OVModel *ov_model = model; |
| 641 | 661 | OVContext *ctx = &ov_model->ctx; |
| 642 | 662 | TaskItem task; |
| @@ -653,7 +673,7 @@ static DNNReturnType get_output_ov(void *model, const char *input_name, int inpu · 10 unmodified lines | ||
| 653 | 673 | |
| 654 | 674 | if (ov_model->model->func_type != DFT_PROCESS_FRAME) { |
| 655 | 675 | av_log(ctx, AV_LOG_ERROR, "Get output dim only when processing frame.\n"); |
| 656 | − return DNN_ERROR; | |
| 676 | + return AVERROR(EINVAL); | |
| 657 | 677 | } |
| 658 | 678 | |
| 659 | 679 | if (ctx->options.input_resizable) { |
| @@ -664,31 +684,33 @@ static DNNReturnType get_output_ov(void *model, const char *input_name, int inpu · 4 unmodified lines | ||
| 664 | 684 | ie_network_input_shapes_free(&input_shapes); |
| 665 | 685 | if (status != OK) { |
| 666 | 686 | av_log(ctx, AV_LOG_ERROR, "Failed to reshape input size for %s\n", input_name); |
| 667 | − return DNN_ERROR; | |
| 687 | + return DNN_GENERIC_ERROR; | |
| 668 | 688 | } |
| 669 | 689 | } |
| 670 | 690 | |
| 671 | 691 | if (!ov_model->exe_network) { |
| 672 | − if (init_model_ov(ov_model, input_name, output_name) != DNN_SUCCESS) { | |
| 692 | + ret = init_model_ov(ov_model, input_name, output_name); | |
| 693 | + if (ret != DNN_SUCCESS) { | |
| 673 | 694 | av_log(ctx, AV_LOG_ERROR, "Failed init OpenVINO exectuable network or inference request\n"); |
| 674 | − return DNN_ERROR; | |
| 695 | + return ret; | |
| 675 | 696 | } |
| 676 | 697 | } |
| 677 | 698 | |
| 678 | − if (ff_dnn_fill_gettingoutput_task(&task, &exec_params, ov_model, input_height, input_width, ctx) != DNN_SUCCESS) { | |
| 679 | − return DNN_ERROR; | |
| 699 | + ret = ff_dnn_fill_gettingoutput_task(&task, &exec_params, ov_model, input_height, input_width, ctx); | |
| 700 | + if (ret != DNN_SUCCESS) { | |
| 701 | + goto err; | |
| 680 | 702 | } |
| 681 | 703 | |
| 682 | − if (extract_lltask_from_task(ov_model->model->func_type, &task, ov_model->lltask_queue, NULL) != DNN_SUCCESS) { | |
| 683 | − av_log(ctx, AV_LOG_ERROR, "unable to extract last level task from task.\n"); | |
| 684 | − ret = DNN_ERROR; | |
| 704 | + ret = extract_lltask_from_task(ov_model->model->func_type, &task, ov_model->lltask_queue, NULL); | |
| 705 | + if (ret != DNN_SUCCESS) { | |
| 706 | + av_log(ctx, AV_LOG_ERROR, "unable to extract inference from task.\n"); | |
| 685 | 707 | goto err; |
| 686 | 708 | } |
| 687 | 709 | |
| 688 | 710 | request = ff_safe_queue_pop_front(ov_model->request_queue); |
| 689 | 711 | if (!request) { |
| 690 | 712 | av_log(ctx, AV_LOG_ERROR, "unable to get infer request.\n"); |
| 691 | − ret = DNN_ERROR; | |
| 713 | + ret = AVERROR(EINVAL); | |
| 692 | 714 | goto err; |
| 693 | 715 | } |
| 694 | 716 | |
| @@ -758,45 +780,49 @@ err: · 63 unmodified lines | ||
| 758 | 780 | return NULL; |
| 759 | 781 | } |
| 760 | 782 | |
| 761 | −DNNReturnType ff_dnn_execute_model_ov(const DNNModel *model, DNNExecBaseParams *exec_params) | |
| 783 | +int ff_dnn_execute_model_ov(const DNNModel *model, DNNExecBaseParams *exec_params) | |
| 762 | 784 | { |
| 763 | 785 | OVModel *ov_model = model->model; |
| 764 | 786 | OVContext *ctx = &ov_model->ctx; |
| 765 | 787 | OVRequestItem *request; |
| 766 | 788 | TaskItem *task; |
| 767 | − DNNReturnType ret; | |
| 789 | + int ret; | |
| 768 | 790 | |
| 769 | − if (ff_check_exec_params(ctx, DNN_OV, model->func_type, exec_params) != 0) { | |
| 770 | − return DNN_ERROR; | |
| 791 | + ret = ff_check_exec_params(ctx, DNN_OV, model->func_type, exec_params); | |
| 792 | + if (ret != 0) { | |
| 793 | + return ret; | |
| 771 | 794 | } |
| 772 | 795 | |
| 773 | 796 | if (!ov_model->exe_network) { |
| 774 | − if (init_model_ov(ov_model, exec_params->input_name, exec_params->output_names[0]) != DNN_SUCCESS) { | |
| 797 | + ret = init_model_ov(ov_model, exec_params->input_name, exec_params->output_names[0]); | |
| 798 | + if (ret != DNN_SUCCESS) { | |
| 775 | 799 | av_log(ctx, AV_LOG_ERROR, "Failed init OpenVINO exectuable network or inference request\n"); |
| 776 | − return DNN_ERROR; | |
| 800 | + return ret; | |
| 777 | 801 | } |
| 778 | 802 | } |
| 779 | 803 | |
| 780 | 804 | task = av_malloc(sizeof(*task)); |
| 781 | 805 | if (!task) { |
| 782 | 806 | av_log(ctx, AV_LOG_ERROR, "unable to alloc memory for task item.\n"); |
| 783 | − return DNN_ERROR; | |
| 807 | + return AVERROR(ENOMEM); | |
| 784 | 808 | } |
| 785 | 809 | |
| 786 | − if (ff_dnn_fill_task(task, exec_params, ov_model, ctx->options.async, 1) != DNN_SUCCESS) { | |
| 810 | + ret = ff_dnn_fill_task(task, exec_params, ov_model, ctx->options.async, 1); | |
| 811 | + if (ret != DNN_SUCCESS) { | |
| 787 | 812 | av_freep(&task); |
| 788 | − return DNN_ERROR; | |
| 813 | + return ret; | |
| 789 | 814 | } |
| 790 | 815 | |
| 791 | 816 | if (ff_queue_push_back(ov_model->task_queue, task) < 0) { |
| 792 | 817 | av_freep(&task); |
| 793 | 818 | av_log(ctx, AV_LOG_ERROR, "unable to push back task_queue.\n"); |
| 794 | − return DNN_ERROR; | |
| 819 | + return AVERROR(ENOMEM); | |
| 795 | 820 | } |
| 796 | 821 | |
| 797 | − if (extract_lltask_from_task(model->func_type, task, ov_model->lltask_queue, exec_params) != DNN_SUCCESS) { | |
| 822 | + ret = extract_lltask_from_task(model->func_type, task, ov_model->lltask_queue, exec_params); | |
| 823 | + if (ret != DNN_SUCCESS) { | |
| 798 | 824 | av_log(ctx, AV_LOG_ERROR, "unable to extract inference from task.\n"); |
| 799 | − return DNN_ERROR; | |
| 825 | + return ret; | |
| 800 | 826 | } |
| 801 | 827 | |
| 802 | 828 | if (ctx->options.async) { |
| @@ -804,7 +830,7 @@ DNNReturnType ff_dnn_execute_model_ov(const DNNModel *model, DNNExecBaseParams * · 1 unmodified line | ||
| 804 | 830 | request = ff_safe_queue_pop_front(ov_model->request_queue); |
| 805 | 831 | if (!request) { |
| 806 | 832 | av_log(ctx, AV_LOG_ERROR, "unable to get infer request.\n"); |
| 807 | − return DNN_ERROR; | |
| 833 | + return AVERROR(EINVAL); | |
| 808 | 834 | } |
| 809 | 835 | |
| 810 | 836 | ret = execute_model_ov(request, ov_model->lltask_queue); |
| @@ -820,18 +846,18 @@ DNNReturnType ff_dnn_execute_model_ov(const DNNModel *model, DNNExecBaseParams * · 9 unmodified lines | ||
| 820 | 846 | // Classification filter has not been completely |
| 821 | 847 | // tested with the sync mode. So, do not support now. |
| 822 | 848 | avpriv_report_missing_feature(ctx, "classify for sync execution"); |
| 823 | − return DNN_ERROR; | |
| 849 | + return AVERROR(ENOSYS); | |
| 824 | 850 | } |
| 825 | 851 | |
| 826 | 852 | if (ctx->options.batch_size > 1) { |
| 827 | 853 | avpriv_report_missing_feature(ctx, "batch mode for sync execution"); |
| 828 | − return DNN_ERROR; | |
| 854 | + return AVERROR(ENOSYS); | |
| 829 | 855 | } |
| 830 | 856 | |
| 831 | 857 | request = ff_safe_queue_pop_front(ov_model->request_queue); |
| 832 | 858 | if (!request) { |
| 833 | 859 | av_log(ctx, AV_LOG_ERROR, "unable to get infer request.\n"); |
| 834 | − return DNN_ERROR; | |
| 860 | + return AVERROR(EINVAL); | |
| 835 | 861 | } |
| 836 | 862 | return execute_model_ov(request, ov_model->lltask_queue); |
| 837 | 863 | } |
| @@ -843,13 +869,13 @@ DNNAsyncStatusType ff_dnn_get_result_ov(const DNNModel *model, AVFrame **in, AVF · 5 unmodified lines | ||
| 843 | 869 | return ff_dnn_get_result_common(ov_model->task_queue, in, out); |
| 844 | 870 | } |
| 845 | 871 | |
| 846 | −DNNReturnType ff_dnn_flush_ov(const DNNModel *model) | |
| 872 | +int ff_dnn_flush_ov(const DNNModel *model) | |
| 847 | 873 | { |
| 848 | 874 | OVModel *ov_model = model->model; |
| 849 | 875 | OVContext *ctx = &ov_model->ctx; |
| 850 | 876 | OVRequestItem *request; |
| 851 | 877 | IEStatusCode status; |
| 852 | − DNNReturnType ret; | |
| 878 | + int ret; | |
| 853 | 879 | |
| 854 | 880 | if (ff_queue_size(ov_model->lltask_queue) == 0) { |
| 855 | 881 | // no pending task need to flush |
| @@ -859,7 +885,7 @@ DNNReturnType ff_dnn_flush_ov(const DNNModel *model) · 3 unmodified lines | ||
| 859 | 885 | request = ff_safe_queue_pop_front(ov_model->request_queue); |
| 860 | 886 | if (!request) { |
| 861 | 887 | av_log(ctx, AV_LOG_ERROR, "unable to get infer request.\n"); |
| 862 | − return DNN_ERROR; | |
| 888 | + return AVERROR(EINVAL); | |
| 863 | 889 | } |
| 864 | 890 | |
| 865 | 891 | ret = fill_model_input_ov(ov_model, request); |
| @@ -870,12 +896,12 @@ DNNReturnType ff_dnn_flush_ov(const DNNModel *model) · 4 unmodified lines | ||
| 870 | 896 | status = ie_infer_set_completion_callback(request->infer_request, &request->callback); |
| 871 | 897 | if (status != OK) { |
| 872 | 898 | av_log(ctx, AV_LOG_ERROR, "Failed to set completion callback for inference\n"); |
| 873 | − return DNN_ERROR; | |
| 899 | + return DNN_GENERIC_ERROR; | |
| 874 | 900 | } |
| 875 | 901 | status = ie_infer_request_infer_async(request->infer_request); |
| 876 | 902 | if (status != OK) { |
| 877 | 903 | av_log(ctx, AV_LOG_ERROR, "Failed to start async inference\n"); |
| 878 | − return DNN_ERROR; | |
| 904 | + return DNN_GENERIC_ERROR; | |
| 879 | 905 | } |
| 880 | 906 | |
| 881 | 907 | return DNN_SUCCESS; |
| @@ -31,9 +31,9 @@ · 30 unmodified lines | ||
| 31 | 31 | |
| 32 | 32 | DNNModel *ff_dnn_load_model_ov(const char *model_filename, DNNFunctionType func_type, const char *options, AVFilterContext *filter_ctx); |
| 33 | 33 | |
| 34 | −DNNReturnType ff_dnn_execute_model_ov(const DNNModel *model, DNNExecBaseParams *exec_params); | |
| 34 | +int ff_dnn_execute_model_ov(const DNNModel *model, DNNExecBaseParams *exec_params); | |
| 35 | 35 | DNNAsyncStatusType ff_dnn_get_result_ov(const DNNModel *model, AVFrame **in, AVFrame **out); |
| 36 | −DNNReturnType ff_dnn_flush_ov(const DNNModel *model); | |
| 36 | +int ff_dnn_flush_ov(const DNNModel *model); | |
| 37 | 37 | |
| 38 | 38 | void ff_dnn_free_model_ov(DNNModel **model); |
| 39 | 39 | |
| @@ -94,9 +94,9 @@ typedef struct DNNModel{ · 93 unmodified lines | ||
| 94 | 94 | DNNFunctionType func_type; |
| 95 | 95 | // Gets model input information |
| 96 | 96 | // Just reuse struct DNNData here, actually the DNNData.data field is not needed. |
| 97 | − DNNReturnType (*get_input)(void *model, DNNData *input, const char *input_name); | |
| 97 | + int (*get_input)(void *model, DNNData *input, const char *input_name); | |
| 98 | 98 | // Gets model output width/height with given input w/h |
| 99 | − DNNReturnType (*get_output)(void *model, const char *input_name, int input_width, int input_height, | |
| 99 | + int (*get_output)(void *model, const char *input_name, int input_width, int input_height, | |
| 100 | 100 | const char *output_name, int *output_width, int *output_height); |
| 101 | 101 | // set the pre process to transfer data from AVFrame to DNNData |
| 102 | 102 | // the default implementation within DNN is used if it is not provided by the filter |
| @@ -114,12 +114,12 @@ typedef struct DNNModel{ · 11 unmodified lines | ||
| 114 | 114 | typedef struct DNNModule{ |
| 115 | 115 | // Loads model and parameters from given file. Returns NULL if it is not possible. |
| 116 | 116 | DNNModel *(*load_model)(const char *model_filename, DNNFunctionType func_type, const char *options, AVFilterContext *filter_ctx); |
| 117 | − // Executes model with specified input and output. Returns DNN_ERROR otherwise. | |
| 118 | − DNNReturnType (*execute_model)(const DNNModel *model, DNNExecBaseParams *exec_params); | |
| 117 | + // Executes model with specified input and output. Returns the error code otherwise. | |
| 118 | + int (*execute_model)(const DNNModel *model, DNNExecBaseParams *exec_params); | |
| 119 | 119 | // Retrieve inference result. |
| 120 | 120 | DNNAsyncStatusType (*get_result)(const DNNModel *model, AVFrame **in, AVFrame **out); |
| 121 | 121 | // Flush all the pending tasks. |
| 122 | − DNNReturnType (*flush)(const DNNModel *model); | |
| 122 | + int (*flush)(const DNNModel *model); | |
| 123 | 123 | // Frees memory allocated for model. |
| 124 | 124 | void (*free_model)(DNNModel **model); |
| 125 | 125 | } DNNModule; |