C++ (Cpp) XCAM_OBJ_PROFILING_END Examples

Example #1

File: cl_bayer_basic_handler.cpp Project: liuyinhangx/libxcam

XCamReturn
CLBayerBasicImageHandler::process_stats_buffer (SmartPtr<VideoBuffer> &buffer, SmartPtr<CLBuffer> &cl_stats)
{
    SmartPtr<X3aStats> stats_3a;
    SmartPtr<CLContext> context = get_context ();

    XCAM_OBJ_PROFILING_START;

    context->finish ();
    stats_3a = _3a_stats_context->copy_stats_out (cl_stats);
    if (!stats_3a.ptr ()) {
        XCAM_LOG_DEBUG ("copy 3a stats failed, maybe handler stopped");
        return XCAM_RETURN_ERROR_CL;
    }

    stats_3a->set_timestamp (buffer->get_timestamp ());
    buffer->attach_buffer (stats_3a);

    if (cl_stats.ptr ())
        _3a_stats_context->release_buffer (cl_stats);

    XCAM_OBJ_PROFILING_END ("3a_stats_cpu_copy(async)", XCAM_OBJ_DUR_FRAME_NUM);

    return post_stats (stats_3a);
}

Example #2

File: cl_kernel.cpp Project: liuyinhangx/libxcam

XCamReturn
CLKernel::execute (
    const SmartPtr<CLKernel> self,
    bool block,
    CLEventList &events,
    SmartPtr<CLEvent> &event_out)
{
    XCAM_ASSERT (self.ptr () == this);
    XCAM_ASSERT (_context.ptr ());
    SmartPtr<CLEvent> kernel_event = event_out;

    if (!block && !kernel_event.ptr ()) {
        kernel_event = new CLEvent;
    }

#if ENABLE_DEBUG_KERNEL
    XCAM_OBJ_PROFILING_START;
#endif

    XCamReturn ret = _context->execute_kernel (self, NULL, events, kernel_event);

    XCAM_FAIL_RETURN (
        ERROR,
        ret == XCAM_RETURN_NO_ERROR,
        ret,
        "kernel(%s) execute failed", XCAM_STR(_name));


    if (block) {
        _context->finish ();
    } else {
        XCAM_ASSERT (kernel_event.ptr () && kernel_event->get_event_id ());
        KernelUserData *user_data = new KernelUserData (self, kernel_event);
        user_data->arg_list.swap (_arg_list);
        ret = _context->set_event_callback (kernel_event, CL_COMPLETE, event_notify, user_data);
        if (ret != XCAM_RETURN_NO_ERROR) {
            XCAM_LOG_WARNING ("kernel(%s) set event callback failed", XCAM_STR (_name));
            _context->finish ();
            delete user_data;
        }
    }
    _arg_list.clear ();

#if ENABLE_DEBUG_KERNEL
    _context->finish ();
    char name[1024];
    snprintf (name, 1024, "%s-%p", XCAM_STR (_name), this);
    XCAM_OBJ_PROFILING_END (name, XCAM_OBJ_DUR_FRAME_NUM);
#endif
    return ret;
}

Example #3

File: cl_image_handler.cpp Project: dulton/libxcam

XCamReturn
CLImageHandler::execute (SmartPtr<DrmBoBuffer> &input, SmartPtr<DrmBoBuffer> &output)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;

    XCAM_FAIL_RETURN (
        WARNING,
        !_kernels.empty (),
        XCAM_RETURN_ERROR_PARAM,
        "cl_image_handler(%s) no image kernel set", XCAM_STR (_name));

    if (!is_kernels_enabled ()) {
        output = input;
        return XCAM_RETURN_NO_ERROR;
    }

    XCAM_OBJ_PROFILING_START;

    XCAM_FAIL_RETURN (
        WARNING,
        (ret = prepare_output_buf (input, output)) == XCAM_RETURN_NO_ERROR,
        ret,
        "cl_image_handler (%s) prepare output buf failed", XCAM_STR (_name));

    XCAM_ASSERT (output.ptr ());

    for (KernelList::iterator i_kernel = _kernels.begin ();
            i_kernel != _kernels.end (); ++i_kernel) {
        SmartPtr<CLImageKernel> &kernel = *i_kernel;

        XCAM_FAIL_RETURN (
            WARNING,
            kernel.ptr(),
            ret,
            "kernel empty");

        if (!kernel->is_enabled ())
            continue;

        XCAM_FAIL_RETURN (
            WARNING,
            (ret = kernel->pre_execute (input, output)) == XCAM_RETURN_NO_ERROR,
            ret,
            "cl_image_handler(%s) pre_execute kernel(%s) failed",
            XCAM_STR (_name), kernel->get_kernel_name ());

        XCAM_FAIL_RETURN (
            WARNING,
            (ret = kernel->execute ()) == XCAM_RETURN_NO_ERROR,
            ret,
            "cl_image_handler(%s) execute kernel(%s) failed",
            XCAM_STR (_name), kernel->get_kernel_name ());

    }

#if ENABLE_PROFILING
    CLDevice::instance()->get_context ()->finish ();
#endif

    // for post_execute
    for (KernelList::iterator i_kernel = _kernels.begin ();
            i_kernel != _kernels.end (); ++i_kernel) {
        SmartPtr<CLImageKernel> &kernel = *i_kernel;

        ret = kernel->post_execute (output);
        XCAM_FAIL_RETURN (
            WARNING,
            (ret == XCAM_RETURN_NO_ERROR || ret == XCAM_RETURN_BYPASS),
            ret,
            "cl_image_handler(%s) post_execute kernel(%s) failed",
            XCAM_STR (_name), kernel->get_kernel_name ());

        if (ret == XCAM_RETURN_BYPASS)
            break;
    }

    XCAM_OBJ_PROFILING_END (XCAM_STR (_name), 30);

    return ret;
}