/*
 * Copyright (C) 2021 Amlogic Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include <string>
#include <sys/utsname.h>
#include "wayland_display.h"
#include "ErrorCode.h"
#include "Logger.h"
#include "wayland_plugin.h"
#include "wayland_videoformat.h"
#include "wayland_shm.h"
#include "wayland_dma.h"
#include "wayland_buffer.h"
#include "Times.h"

#ifndef MAX
#  define MAX(a,b)  ((a) > (b)? (a) : (b))
#  define MIN(a,b)  ((a) < (b)? (a) : (b))
#endif

#define UNUSED_PARAM(x) ((void)(x))
#define INVALID_OUTPUT_INDEX (-1)

#define TAG "rlib:wayland_display"
#define FRAME_FREEZE_THRESHOLD(x) (x*1.67)
#define DETECT_FRAMERATE_CNT (5)
/*do not use -1 to indicate invalid pts.
player maybe display -1 pts frame*/
#define INVALID_PTS (INT64_MIN)
#define DUMP_WAYLAND_BUFFER_LOG (0)

/**
 * @brief this log function registered to wayland protocol
 * to print wayland server or wayland log
 * @param fmt log format
 */
static void wl_log_handle(const char *format, va_list args)
{
    wl_log(format, args);
}

void WaylandDisplay::dmabuf_modifiers(void *data, struct zwp_linux_dmabuf_v1 *zwp_linux_dmabuf,
         uint32_t format, uint32_t modifier_hi, uint32_t modifier_lo)
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    ATools::Mutex::Autolock _l(self->mMutex);
    if (wl_dmabuf_format_to_video_format (format) != VIDEO_FORMAT_UNKNOWN) {
        TRACE(self->mLogCategory,"regist dmabuffer format:%d (%s) hi:%x,lo:%x",format,print_dmabuf_format_name(format),modifier_hi,modifier_lo);
        uint64_t modifier = ((uint64_t)modifier_hi << 32) | modifier_lo;
        auto item = self->mDmaBufferFormats.find(format);
        if (item == self->mDmaBufferFormats.end()) {
            std::pair<uint32_t ,uint64_t> item(format, modifier);
            self->mDmaBufferFormats.insert(item);
        } else { //found format
            item->second = modifier;
        }
    }
}

void
WaylandDisplay::dmaBufferFormat (void *data, struct zwp_linux_dmabuf_v1 *zwp_linux_dmabuf,
    uint32_t format)
{
#if 0
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);

    if (wl_dmabuf_format_to_video_format (format) != VIDEO_FORMAT_UNKNOWN) {
        TRACE(mLogCategory,"regist dmabuffer format:%d : %s",format);
        //self->mDmaBufferFormats.push_back(format);
    }
#endif
   /* XXX: deprecated */
}

static const struct zwp_linux_dmabuf_v1_listener dmabuf_listener = {
    WaylandDisplay::dmaBufferFormat,
    WaylandDisplay::dmabuf_modifiers
};

static void
handle_xdg_wm_base_ping (void *user_data, struct xdg_wm_base *xdg_wm_base,
    uint32_t serial)
{
  xdg_wm_base_pong (xdg_wm_base, serial);
}

static const struct xdg_wm_base_listener xdg_wm_base_listener = {
  handle_xdg_wm_base_ping
};

void WaylandDisplay::shmFormat(void *data, struct wl_shm *wl_shm, uint32_t format)
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    self->mShmFormats.push_back(format);
}

static const struct wl_shm_listener shm_listener = {
  WaylandDisplay::shmFormat
};

void WaylandDisplay::outputHandleGeometry( void *data,
                                  struct wl_output *output,
                                  int x,
                                  int y,
                                  int physicalWidth,
                                  int physicalHeight,
                                  int subPixel,
                                  const char *make,
                                  const char *model,
                                  int transform )
{
    UNUSED_PARAM(make);
    UNUSED_PARAM(model);

    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    DEBUG(self->mLogCategory,"wl_output %p x:%d,y:%d,physicalWidth:%d,physicalHeight:%d,subPixel:%d,trans:%d",
            output,x, y,physicalWidth, physicalHeight,subPixel,transform);
    ATools::Mutex::Autolock _l(self->mMutex);
    for (int i = 0; i < DEFAULT_DISPLAY_OUTPUT_NUM; i++) {
        if (output == self->mOutput[i].wlOutput) {
            self->mOutput[i].offsetX = x;
            self->mOutput[i].offsetY = y;
        }
    }
    self->mDefaultTransform = transform;
}

void WaylandDisplay::outputHandleMode( void *data,
                              struct wl_output *output,
                              uint32_t flags,
                              int width,
                              int height,
                              int refreshRate )
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);

    if ( flags & WL_OUTPUT_MODE_CURRENT ) {
        ATools::Mutex::Autolock _l(self->mMutex);
        for (int i = 0; i < DEFAULT_DISPLAY_OUTPUT_NUM; i++) {
            if (output == self->mOutput[i].wlOutput) {
                self->mOutput[i].width = width;
                self->mOutput[i].height = height;
                self->mOutput[i].refreshRate = refreshRate;
            }
        }

        DEBUG(self->mLogCategory,"wl_output: %p (%dx%d) refreshrate:%d,select output index %d",output, width, height,refreshRate,self->mSelectOutputIndex);
        if (self->mCurrentDisplayOutput->width > 0 &&
            self->mCurrentDisplayOutput->height > 0) {
            self->updateDisplayOutput();
        }
    }
}

void WaylandDisplay::outputHandleDone( void *data,
                              struct wl_output *output )
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    DEBUG(self->mLogCategory,"wl_output: %p",output);
    UNUSED_PARAM(data);
    UNUSED_PARAM(output);
}

void WaylandDisplay::outputHandleScale( void *data,
                               struct wl_output *output,
                               int32_t scale )
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    DEBUG(self->mLogCategory,"wl_output: %p scale %d",output, scale);
    UNUSED_PARAM(data);
    UNUSED_PARAM(output);
    UNUSED_PARAM(scale);
}

void WaylandDisplay::outputHandleCrtcIndex( void *data,
                              struct wl_output *output,
                              int32_t index )
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    DEBUG(self->mLogCategory,"wl_output: %p crtc index %d",output, index);
    ATools::Mutex::Autolock _l(self->mMutex);
    for (int i = 0; i < DEFAULT_DISPLAY_OUTPUT_NUM; i++) {
        if (output == self->mOutput[i].wlOutput) {
            self->mOutput[i].crtcIndex = index;
        }
    }
}

//aml weston always add crtcIndex in callbacks.
static const struct wl_output_listener outputListener = {
    WaylandDisplay::outputHandleGeometry,
    WaylandDisplay::outputHandleMode,
    WaylandDisplay::outputHandleDone,
    WaylandDisplay::outputHandleScale,
    WaylandDisplay::outputHandleCrtcIndex,
};

void WaylandDisplay::pointerHandleEnter(void *data, struct wl_pointer *pointer,
                                uint32_t serial, struct wl_surface *surface,
                                wl_fixed_t sx, wl_fixed_t sy)
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);

    if (self->mFullScreen) {
        wl_pointer_set_cursor(pointer, serial, NULL, 0, 0);
    }
}

void WaylandDisplay::pointerHandleLeave(void *data, struct wl_pointer *pointer,
                                uint32_t serial, struct wl_surface *surface)
{
    UNUSED_PARAM(data);
    UNUSED_PARAM(pointer);
    UNUSED_PARAM(serial);
    UNUSED_PARAM(surface);
}

void WaylandDisplay::pointerHandleMotion(void *data, struct wl_pointer *pointer,
                                uint32_t time, wl_fixed_t sx, wl_fixed_t sy)
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    int x = wl_fixed_to_int(sx);
    int y = wl_fixed_to_int(sy);
    DEBUG(self->mLogCategory,"pointer motion fixed[%d, %d] to-int: x[%d] y[%d]\n", sx, sy, x, y);
}

void WaylandDisplay::pointerHandleButton(void *data, struct wl_pointer *wl_pointer,
                                    uint32_t serial, uint32_t time, uint32_t button, uint32_t state)
{
    UNUSED_PARAM(data);
    UNUSED_PARAM(wl_pointer);
    UNUSED_PARAM(time);
    UNUSED_PARAM(serial);
    UNUSED_PARAM(button);
    UNUSED_PARAM(state);
}

void WaylandDisplay::pointerHandleAxis(void *data, struct wl_pointer *wl_pointer,
                                    uint32_t time, uint32_t axis, wl_fixed_t value)
{
    UNUSED_PARAM(data);
    UNUSED_PARAM(wl_pointer);
    UNUSED_PARAM(time);
    UNUSED_PARAM(axis);
    UNUSED_PARAM(value);
}

static const struct wl_pointer_listener pointer_listener = {
    WaylandDisplay::pointerHandleEnter,
    WaylandDisplay::pointerHandleLeave,
    WaylandDisplay::pointerHandleMotion,
    WaylandDisplay::pointerHandleButton,
    WaylandDisplay::pointerHandleAxis,
};

void WaylandDisplay::touchHandleDown(void *data, struct wl_touch *wl_touch,
                                    uint32_t serial, uint32_t time, struct wl_surface *surface,
                                    int32_t id, wl_fixed_t x_w, wl_fixed_t y_w)
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
}

void WaylandDisplay::touchHandleUp(void *data, struct wl_touch *wl_touch,
                                    uint32_t serial, uint32_t time, int32_t id)
{
    UNUSED_PARAM(data);
    UNUSED_PARAM(wl_touch);
    UNUSED_PARAM(serial);
    UNUSED_PARAM(time);
    UNUSED_PARAM(id);
}

void WaylandDisplay::touchHandleMotion(void *data, struct wl_touch *wl_touch,
                                    uint32_t time, int32_t id, wl_fixed_t x_w, wl_fixed_t y_w)
{
    UNUSED_PARAM(data);
    UNUSED_PARAM(wl_touch);
    UNUSED_PARAM(time);
    UNUSED_PARAM(id);
    UNUSED_PARAM(x_w);
    UNUSED_PARAM(y_w);
}

void WaylandDisplay::touchHandleFrame(void *data, struct wl_touch *wl_touch)
{
    UNUSED_PARAM(data);
    UNUSED_PARAM(wl_touch);
}

void WaylandDisplay::touchHandleCancel(void *data, struct wl_touch *wl_touch)
{
    UNUSED_PARAM(data);
    UNUSED_PARAM(wl_touch);
}

static const struct wl_touch_listener touch_listener = {
    WaylandDisplay::touchHandleDown,
    WaylandDisplay::touchHandleUp,
    WaylandDisplay::touchHandleMotion,
    WaylandDisplay::touchHandleFrame,
    WaylandDisplay::touchHandleCancel,
};

void WaylandDisplay::keyboardHandleKeymap(void *data, struct wl_keyboard *keyboard,
                                    uint32_t format, int fd, uint32_t size)
{
    UNUSED_PARAM(data);
    UNUSED_PARAM(keyboard);
    UNUSED_PARAM(format);
    UNUSED_PARAM(fd);
    UNUSED_PARAM(size);
}

void WaylandDisplay::keyboardHandleEnter(void *data, struct wl_keyboard *keyboard,
                                    uint32_t serial, struct wl_surface *surface, struct wl_array *keys)
{
    UNUSED_PARAM(data);
    UNUSED_PARAM(keyboard);
    UNUSED_PARAM(serial);
    UNUSED_PARAM(surface);
    UNUSED_PARAM(keys);
}

void WaylandDisplay::keyboardHandleLeave(void *data, struct wl_keyboard *keyboard,
                                    uint32_t serial, struct wl_surface *surface)
{
    UNUSED_PARAM(data);
    UNUSED_PARAM(keyboard);
    UNUSED_PARAM(serial);
    UNUSED_PARAM(surface);
}

void WaylandDisplay::keyboardHandleKey(void *data, struct wl_keyboard *keyboard,
                                    uint32_t serial, uint32_t time, uint32_t key, uint32_t state)
{
    UNUSED_PARAM(data);
    UNUSED_PARAM(keyboard);
    UNUSED_PARAM(serial);
    UNUSED_PARAM(time);
    UNUSED_PARAM(key);
    UNUSED_PARAM(state);
}

void WaylandDisplay::keyboardHandleModifiers(void *data, struct wl_keyboard *keyboard,
                                    uint32_t serial, uint32_t mods_depressed,
                                    uint32_t mods_latched, uint32_t mods_locked,
                                    uint32_t group)
{
    UNUSED_PARAM(data);
    UNUSED_PARAM(keyboard);
    UNUSED_PARAM(serial);
    UNUSED_PARAM(mods_depressed);
    UNUSED_PARAM(mods_latched);
    UNUSED_PARAM(mods_locked);
    UNUSED_PARAM(group);
}

static const struct wl_keyboard_listener keyboard_listener = {
    WaylandDisplay::keyboardHandleKeymap,
    WaylandDisplay::keyboardHandleEnter,
    WaylandDisplay::keyboardHandleLeave,
    WaylandDisplay::keyboardHandleKey,
    WaylandDisplay::keyboardHandleModifiers,
};

void WaylandDisplay::seatHandleCapabilities(void *data, struct wl_seat *seat,
                               uint32_t caps)
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    if ((caps & WL_SEAT_CAPABILITY_POINTER) && !self->mPointer) {
        self->mPointer = wl_seat_get_pointer(seat);
        wl_pointer_add_listener(self->mPointer, &pointer_listener, data);
    } else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && self->mPointer) {
        wl_pointer_destroy(self->mPointer);
        self->mPointer = NULL;
    }

    if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !self->mKeyboard) {
        self->mKeyboard = wl_seat_get_keyboard(seat);
        wl_keyboard_add_listener(self->mKeyboard, &keyboard_listener, data);
    } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && self->mKeyboard) {
        wl_keyboard_destroy(self->mKeyboard);
        self->mKeyboard = NULL;
    }

    if ((caps & WL_SEAT_CAPABILITY_TOUCH) && !self->mTouch) {
        self->mTouch = wl_seat_get_touch(seat);
        wl_touch_set_user_data(self->mTouch, data);
        wl_touch_add_listener(self->mTouch, &touch_listener, data);
    } else if (!(caps & WL_SEAT_CAPABILITY_TOUCH) && self->mTouch) {
        wl_touch_destroy(self->mTouch);
        self->mTouch = NULL;
    }
}

static const struct wl_seat_listener seat_listener = {
    WaylandDisplay::seatHandleCapabilities,
};

void WaylandDisplay::handleXdgToplevelClose (void *data, struct xdg_toplevel *xdg_toplevel)
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);

    INFO(self->mLogCategory,"XDG toplevel got a close event.");
}

void WaylandDisplay::handleXdgToplevelConfigure (void *data, struct xdg_toplevel *xdg_toplevel,
            int32_t width, int32_t height, struct wl_array *states)
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    uint32_t *state;

    /*
    wl_array_for_each (state, states) {
        switch (*state) {
        case XDG_TOPLEVEL_STATE_FULLSCREEN:
        case XDG_TOPLEVEL_STATE_MAXIMIZED:
        case XDG_TOPLEVEL_STATE_RESIZING:
        case XDG_TOPLEVEL_STATE_ACTIVATED:
            break;
        }
    }
    */

    if (width <= 0 || height <= 0)
        return;

    INFO(self->mLogCategory, "XDG toplevel got a configure event, width:height [ %d, %d ].", width, height);

    if (width == self->mCurrentDisplayOutput->width && height == self->mCurrentDisplayOutput->height && self->mUpdateRenderRectangle) {
        self->mUpdateRenderRectangle = false;
        self->setRenderRectangle(self->mCurrentDisplayOutput->offsetX,
                            self->mCurrentDisplayOutput->offsetY,
                            self->mCurrentDisplayOutput->width,
                            self->mCurrentDisplayOutput->height);
    } else{
        self->setRenderRectangle(self->mRenderRect.x, self->mRenderRect.y, width, height);
    }
}

static const struct xdg_toplevel_listener xdg_toplevel_listener = {
    WaylandDisplay::handleXdgToplevelConfigure,
    WaylandDisplay::handleXdgToplevelClose,
};

void WaylandDisplay::handleXdgSurfaceConfigure (void *data, struct xdg_surface *xdg_surface,
    uint32_t serial)
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    xdg_surface_ack_configure (xdg_surface, serial);

    TRACE(self->mLogCategory,"handleXdgSurfaceConfigure");
    ATools::Mutex::Autolock _l(self->mConfigureMutex);
    self->mXdgSurfaceConfigured = true;
    self->updateDisplayOutput();
}

static const struct xdg_surface_listener xdg_surface_listener = {
    WaylandDisplay::handleXdgSurfaceConfigure,
};

void WaylandDisplay::handleSurfaceDestroy(void *data, struct wl_callback *callback, uint32_t time)
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    INFO(self->mLogCategory,"handle video surface destroy");
    if (self->mMutex.lock() == 0) {
        self->mCondition.signal();
        self->mMutex.unlock();
    }
    wl_callback_destroy (callback);
}

static const struct wl_callback_listener surface_destroy_listener = {
    WaylandDisplay::handleSurfaceDestroy,
};

void WaylandDisplay::surfaceEnter(void *data, struct wl_surface *wl_surface, struct wl_output *output)
{
    UNUSED_PARAM(data);
    UNUSED_PARAM(wl_surface);
    UNUSED_PARAM(output);
}

void WaylandDisplay::surfaceLeave(void *data, struct wl_surface *wl_surface, struct wl_output *output)
{
    UNUSED_PARAM(data);
    UNUSED_PARAM(wl_surface);
    UNUSED_PARAM(output);
}

void WaylandDisplay::surfaceUnderFlow(void *data, struct wl_surface *wl_surface, uint32_t pts_hi, uint32_t pts_lo)
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    int64_t displayTime = ((int64_t)pts_hi << 32) | pts_lo;
    INFO(self->mLogCategory,"underflow displaytime:%lld", displayTime);
    self->mWaylandPlugin->reportUnderFlow();
}

static const struct wl_surface_listener surface_listener = {
    WaylandDisplay::surfaceEnter,
    WaylandDisplay::surfaceLeave,
    WaylandDisplay::surfaceUnderFlow,
};

void WaylandDisplay::amlConfigure(void *data, struct aml_config *config, const char *list) {
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    TRACE(self->mLogCategory,"aml_config:%s",list);
    if (list && strlen(list) > 0) {
        if (strstr(list, "set_video_plane")) {
            TRACE(self->mLogCategory,"weston enable set_video_plane");
            self->mAmlConfigAPIList.enableSetVideoPlane = true;
        }
        if (strstr(list, "set_pts")) {
            TRACE(self->mLogCategory,"weston enable set_pts");
            self->mAmlConfigAPIList.enableSetPts = true;
        }
        if (strstr(list, "keep_last_frame")) {
            TRACE(self->mLogCategory,"weston enable keep_last_frame");
            self->mAmlConfigAPIList.enableKeepLastFrame = true;
        }
        if (strstr(list, "surface_destroy_cb")) {
            TRACE(self->mLogCategory,"weston enable surface_destroy_cb");
            self->mAmlConfigAPIList.enableSurfaceDestroyCallback = true;
        }
        if (strstr(list, "set_display_rate")) {
            TRACE(self->mLogCategory,"weston enable set_display_rate");
            self->mAmlConfigAPIList.enableSetDisplayRate = true;
        }
        if (strstr(list, "set_surface_invisible")) {
            TRACE(self->mLogCategory,"weston enable set_surface_invisible");
            self->mAmlConfigAPIList.enableSetSurfaceInvisible = true;
        }
        if (strstr(list, "display_time")) {
            TRACE(self->mLogCategory,"weston enable display_time");
            self->mAmlConfigAPIList.enableDisplayTime = true;
        }
        if (strstr(list, "force_update_rect")) {
            TRACE(self->mLogCategory,"weston enable force_update_rect");
            self->mAmlConfigAPIList.enableForceUpdateRect = true;
        }
        if (strstr(list, "render_to_osd")) {
            TRACE(self->mLogCategory,"weston enable render_to_osd");
            self->mAmlConfigAPIList.enableVideoOnOSD = true;
        }
        if (strstr(list, "need_original_size")) {
            TRACE(self->mLogCategory,"weston enable need_original_size");
            self->mAmlConfigAPIList.enableNeedOriginalSize = true;
        }
        if (strstr(list, "dpss_enabled")) {
            TRACE(self->mLogCategory,"weston enable dpss_enabled");
            self->mAmlConfigAPIList.enableDpss = true;
        }
        if (strstr(list, "vsync_callback")) {
            TRACE(self->mLogCategory,"weston enable vsync_callback");
            self->mAmlConfigAPIList.enableVsyncCallback = true;
        }
    }
}

void WaylandDisplay::dpssLatency(void *data, struct aml_config *config, uint32_t latency)
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    if (self) {
        self->mHWCLatency = (uint32_t)latency;
        TRACE(self->mLogCategory,"compositor latency:%u us",latency);
    }
}

void WaylandDisplay::vsyncCallback(void *data, struct aml_config *config, uint32_t vsync_hi, uint32_t vsync_lo, uint32_t interval)
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    if (self) {
        int64_t lastVsyncUs = self->mVsyncTimeUs;
        self->mVsyncTimeUs = ((int64_t)vsync_hi << 32) | vsync_lo;
        self->mVsyncPeriodUs = (int64_t)interval;
        TRACE(self->mLogCategory,"vsync_hi:%d, vsync_lo:%d, (%lld, %lld->%lld)",
            vsync_hi, vsync_lo, self->mVsyncTimeUs, self->mVsyncPeriodUs,self->mVsyncTimeUs - lastVsyncUs);
    }
}

static const struct aml_config_listener aml_config_listener = {
    WaylandDisplay::amlConfigure,
    WaylandDisplay::vsyncCallback,
    WaylandDisplay::dpssLatency,
};

void
WaylandDisplay::registryHandleGlobal (void *data, struct wl_registry *registry,
    uint32_t name, const char *interface, uint32_t version)
{
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    TRACE(self->mLogCategory,"registryHandleGlobal,name:%u,interface:%s,version:%d",name,interface,version);

    if (strcmp (interface, "wl_compositor") == 0) {
        self->mCompositor = (struct wl_compositor *)wl_registry_bind (registry, name, &wl_compositor_interface, version);
    } else if (strcmp (interface, "wl_subcompositor") == 0) {
        self->mSubCompositor = (struct wl_subcompositor *)wl_registry_bind (registry, name, &wl_subcompositor_interface, 1);
    } else if (strcmp (interface, "xdg_wm_base") == 0) {
        self->mXdgWmBase = (struct xdg_wm_base *)wl_registry_bind (registry, name, &xdg_wm_base_interface, 1);
        xdg_wm_base_add_listener (self->mXdgWmBase, &xdg_wm_base_listener, (void *)self);
    } else if (strcmp (interface, "wl_shm") == 0) {
        self->mShm = (struct wl_shm *)wl_registry_bind (registry, name, &wl_shm_interface, 1);
        wl_shm_add_listener (self->mShm, &shm_listener, self);
    } else if (strcmp (interface, "zwp_fullscreen_shell_v1") == 0) {
        //self->mFullscreenShell = (struct zwp_fullscreen_shell_v1 *)wl_registry_bind (registry, name,
        //    &zwp_fullscreen_shell_v1_interface, 1);
    } else if (strcmp (interface, "wp_viewporter") == 0) {
        self->mViewporter = (struct wp_viewporter *)wl_registry_bind (registry, name, &wp_viewporter_interface, 1);
    } else if (strcmp (interface, "zwp_linux_dmabuf_v1") == 0) {
        if (version < 3)
            return;
        self->mDmabuf = (struct zwp_linux_dmabuf_v1 *)wl_registry_bind (registry, name, &zwp_linux_dmabuf_v1_interface, 3);
        zwp_linux_dmabuf_v1_add_listener (self->mDmabuf, &dmabuf_listener, (void *)self);
    }  else if (strcmp (interface, "wl_output") == 0) {
        int i = 0;
        uint32_t oriName = self->mCurrentDisplayOutput->name;
        for (int i = 0; i < DEFAULT_DISPLAY_OUTPUT_NUM; i++) {
            if (self->mOutput[i].wlOutput ==  NULL) {
                self->mOutput[i].name = name;
                self->mOutput[i].wlOutput = (struct wl_output*)wl_registry_bind(registry, name, &wl_output_interface, version);
                TRACE(self->mLogCategory,"name:%u, wl_output:%p, select:%d",self->mOutput[i].name,self->mOutput[i].wlOutput,self->mSelectOutputIndex);
                wl_output_add_listener(self->mOutput[i].wlOutput, &outputListener, (void *)self);
                if (i == 0) { //primary wl_output
                    self->mOutput[i].isPrimary = true;
                }
                break;
            }
        }
        if (i == DEFAULT_DISPLAY_OUTPUT_NUM) {
            WARNING(self->mLogCategory,"Not enough free output");
        }
        //select current wl_output
        if (self->mSelectOutputIndex != INVALID_OUTPUT_INDEX && !self->isRunning()) {
            TRACE(self->mLogCategory,"select %d output",self->mSelectOutputIndex);
            self->mCurrentDisplayOutput = &self->mOutput[self->mSelectOutputIndex];
        }
        //if user select a wrong output index, we using a suiteble wl_output
        if (self->mCurrentDisplayOutput->wlOutput == NULL) {
            WARNING(self->mLogCategory,"wl_output is null,we should find a suiteble output");
            for (i = 0; i < DEFAULT_DISPLAY_OUTPUT_NUM; i++) {
                if (self->mOutput[i].wlOutput) {
                    self->mCurrentDisplayOutput = &self->mOutput[i];
                    break;
                }
            }
        }
        //if current wl_output update, we should update render rectangle
        if (self->mCurrentDisplayOutput->name != oriName) {
            self->mUpdateRenderRectangle = true;
        }
        //if wl_output plugin,active sending frame
        self->setRedrawingPending(false);
    } else if (strcmp(interface, "wl_seat") == 0) {
        //self->mSeat = (struct wl_seat *)wl_registry_bind(registry, name, &wl_seat_interface, 1);
        //wl_seat_add_listener(self->mSeat, &seat_listener, (void *)self);
    } else if (strcmp(interface, "weston_direct_display_v1") == 0) {
        self->mDirect_display = (struct weston_direct_display_v1 *)wl_registry_bind(registry,name, &weston_direct_display_v1_interface, 1);
    } else if (strcmp(interface, "aml_config") == 0) {
        self->mAmlConfig = (struct aml_config*)wl_registry_bind(registry, name, &aml_config_interface, 1);
        aml_config_add_listener(self->mAmlConfig, &aml_config_listener, (void *)self);
    }
}

void
WaylandDisplay::registryHandleGlobalRemove (void *data, struct wl_registry *registry, uint32_t name)
{
    int i = 0;
    WaylandDisplay *self = static_cast<WaylandDisplay *>(data);
    /* check wl_output changed */
    DEBUG(self->mLogCategory,"wayland display remove registry handle global,name:%u",name);
    //if user selected wl_output removed, reset selected output index
    if (self->mSelectOutputIndex != INVALID_OUTPUT_INDEX &&
        self->mOutput[self->mSelectOutputIndex].wlOutput &&
        self->mOutput[self->mSelectOutputIndex].name == name) {
            self->mSelectOutputIndex = INVALID_OUTPUT_INDEX;
    }
    for (i = 0; i < DEFAULT_DISPLAY_OUTPUT_NUM; i++) {
        if (self->mOutput[i].name == name) {
            DEBUG(self->mLogCategory,"remove wl_output name:%u,wl_output:%p",name,self->mOutput[i].wlOutput);
            self->mOutput[i].name = 0;
            if (self->mOutput[i].wlOutput) {
                wl_output_destroy(self->mOutput[i].wlOutput);
            }
            self->mOutput[i].wlOutput = NULL;
        }
    }
    //if current output removed, select a suiteble output
    if (self->mCurrentDisplayOutput->wlOutput == NULL) {
        for (i = 0; i < DEFAULT_DISPLAY_OUTPUT_NUM; i++) {
            if (self->mOutput[i].wlOutput) {
                self->mCurrentDisplayOutput = &self->mOutput[i];
                self->mUpdateRenderRectangle = true;
            }
        }
        //set new output rectangle
        if (self->mUpdateRenderRectangle) {
            self->mUpdateRenderRectangle = false;
            self->setRenderRectangle(self->mCurrentDisplayOutput->offsetX,
                                    self->mCurrentDisplayOutput->offsetY,
                                    self->mCurrentDisplayOutput->width,
                                    self->mCurrentDisplayOutput->height);
        }
    }
}

static const struct wl_registry_listener registry_listener = {
  WaylandDisplay::registryHandleGlobal,
  WaylandDisplay::registryHandleGlobalRemove
};

WaylandDisplay::WaylandDisplay(WaylandPlugin *plugin, int logCategory)
    :mBufferMutex("bufferMutex"),
    mWaylandPlugin(plugin),
    mLogCategory(logCategory)
{
    TRACE(mLogCategory,"construct WaylandDisplay");
    mWlDisplay = NULL;
    mWlDisplayWrapper = NULL;
    mWlQueue = NULL;
    mRegistry = NULL;
    mCompositor = NULL;
    mXdgWmBase = NULL;
    mViewporter = NULL;
    mDmabuf = NULL;
    mShm = NULL;
    mSeat = NULL;
    mPointer = NULL;
    mTouch = NULL;
    mKeyboard = NULL;
    mDirect_display = NULL;
    mSelectOutputIndex = INVALID_OUTPUT_INDEX;
    mPoll = NULL;
    //window
    mVideoWidth = 0;
    mVideoHeight = 0;
    mVideoSurface = NULL;
    mXdgSurface = NULL;
    mXdgToplevel = NULL;
    mAreaViewport = NULL;
    mVideoViewport = NULL;
    mAreaShmBuffer = NULL;
    mCommitCnt = 0;
    mAreaSurface = NULL;
    mAreaSurfaceWrapper = NULL;
    mVideoSurfaceWrapper = NULL;
    mVideoSubSurface = NULL;
    mPip = 0;
    mKeepLastFrame = 0; //default is off keep last frame
    mKeepFrameOnFlush = 1;
    mFirstPtsAfterFlush = INVALID_PTS;
    mSignalFirstFramePts = false;
    mFirstFramePts = INVALID_PTS;
    mToSendKeepLastFrame = false;
    mVideoPlaneZorder = -1;
    mVideoPlaneZorderChanged = false;
    mVideoRotateDegree = -1;
    mEnableWaylandClientLog = false;
    mMuteVideoOnFlush = false;
    mPaused = false;
    mKeepVideoAsptectRatio = true;
    mHideVideo = 0;
    mHideVideoChanged = false;
    mDisplayConnected = false;
    mVideoOnOSD = false;
    mDefaultTransform = 0;
    mHWCLatency = 0;
    mVsyncTimeUs = 0;
    mVsyncPeriodUs = 0;
    memset(&mWindowRect, 0, sizeof(struct Rectangle));
    memset(&mCropRect, 0, sizeof(struct Rectangle));
    mCommittedBufferMap.clear();
    mWaylandBuffersMap.clear();
    mDmaBufferFormats.clear();
    mDeferredReleaseBuffers.clear();
}

WaylandDisplay::~WaylandDisplay()
{
    TRACE(mLogCategory,"desconstruct WaylandDisplay");
}

char *WaylandDisplay::require_xdg_runtime_dir()
{
    char *val = getenv("XDG_RUNTIME_DIR");
    INFO(mLogCategory,"XDG_RUNTIME_DIR=%s",val);
    //if not set XDG_RUNTIME_DIR,set default value
    // if (!val) {
    //     val = const_cast<char *>("/run/user/0");
    //     setenv("XDG_RUNTIME_DIR",val,0);
    //     WARNING(mLogCategory,"XDG_RUNTIME_DIR is not set,set default %s",val);
    // }

    return val;
}

int WaylandDisplay::openDisplay()
{
    mPoll = new ATools::Poll(true);
    mPrepareFrameWidth = 0;
    mPrepareFrameHeight = 0;
    mWaylandBufferCookieId = 0;
    mDisplayedFrameWidth = 0;
    mDisplayedFrameHeight = 0;
    mUpdateWaylandBuffersMap = false;
    frameCallbackTimeUs = 0;
    mLastDisplayFramePts = -1;
    mLastDisplayFrameTimeUs = -1;
    mFrameDurationUs = 0;
    mPreFramePts = -1;
    mFrameRateDetectCnt = 0;
    mFrameRateDetectPeriod = 0;
    mPixelAspectRatio = 1.0;
    mUpdateVideoSurface = false;
    mUpdateCropSize = false;
    mNoBorderUpdate = false;
    mReCommitAreaSurface = false;
    mXdgSurfaceConfigured = false;
    mUpdateRenderRectangle = false;
    mFrameRateFractionNum = 0;
    mFrameRateFractionDenom = 1;
    mFrameRateChanged = false;
    mVideoPlaneZorder = -1;
    mVideoPlaneZorderChanged = false;
    mVideoIsUnderflow = false;
    mSignalFirstFramePts = false;
    mFirstFramePts = INVALID_PTS;
    mPaused = false;
    mMuteVideoOnFlush = false;
    mDisplayConnected = false;
    memset(&mRenderRect, 0, sizeof(struct Rectangle));
    memset(&mVideoRect, 0, sizeof(struct Rectangle));
    mDeferredReleaseBuffers.clear();
    //don't full screen when osd displayed
    if (!mVideoOnOSD) {
        mFullScreen = true; //default is full screen
    }
    mAmlConfig = NULL;
    //weston config private api
    mAmlConfigAPIList.enableKeepLastFrame = false;
    mAmlConfigAPIList.enableSetPts = false;
    mAmlConfigAPIList.enableSetVideoPlane = false;
    mAmlConfigAPIList.enableSurfaceDestroyCallback = false;
    mAmlConfigAPIList.enableSetDisplayRate = false;
    mAmlConfigAPIList.enableSetSurfaceInvisible = false;
    mAmlConfigAPIList.enableDisplayTime = false;
    mAmlConfigAPIList.enableForceUpdateRect = false;
    mAmlConfigAPIList.enableVideoOnOSD = false;
    mAmlConfigAPIList.enableNeedOriginalSize = false;
    mAmlConfigAPIList.enableDpss = false;
    mAmlConfigAPIList.enableVsyncCallback = false;
    mCurrentDisplayOutput = &mOutput[0];
    for (int i = 0; i < DEFAULT_DISPLAY_OUTPUT_NUM; i++) {
        mOutput[i].wlOutput = NULL;
        mOutput[i].offsetX = 0;
        mOutput[i].offsetY = 0;
        mOutput[i].width = 0;
        mOutput[i].height = 0;
        mOutput[i].refreshRate = 0;
        mOutput[i].isPrimary = false;
        mOutput[i].name = 0;
        mOutput[i].crtcIndex = 0;
    }
    /*if mKeepLastFrame had set but mToSendKeepLastFrame is false,maybe
    playback is doing FF/FW action，so we keep set it on new connection*/
    if (!mToSendKeepLastFrame && mKeepLastFrame) {
        mToSendKeepLastFrame = true;
    }
    char *name = require_xdg_runtime_dir();
    //DEBUG(mLogCategory,"name:%s",name);
    char* debug = getenv("WAYLAND_DEBUG");
    if (debug && strstr(debug, "1")) {
        mEnableWaylandClientLog = true;
        wl_log_set_handler_client(wl_log_handle);
    }
    debug = getenv("VIDEO_RENDER_KEEP_VIDEO_ASPECT_RATIO");
    if (debug && strstr(debug, "0")) {
        mKeepVideoAsptectRatio = false;
    }
    DEBUG(mLogCategory,"openDisplay in");
    mWlDisplay = wl_display_connect(NULL);
    if (!mWlDisplay) {
        ERROR(mLogCategory,"Failed to connect to the wayland display, XDG_RUNTIME_DIR='%s'",
        name ? name : "NULL");
        return ERROR_OPEN_FAIL;
    }

    mWlDisplayWrapper = (struct wl_display *)wl_proxy_create_wrapper ((void *)mWlDisplay);
    mWlQueue = wl_display_create_queue (mWlDisplay);
    wl_proxy_set_queue ((struct wl_proxy *)mWlDisplayWrapper, mWlQueue);

    mRegistry = wl_display_get_registry (mWlDisplayWrapper);
    wl_registry_add_listener (mRegistry, &registry_listener, (void *)this);

    /* we need exactly 2 roundtrips to discover global objects and their state */
    for (int i = 0; i < 2; i++) {
        if (wl_display_roundtrip_queue (mWlDisplay, mWlQueue) < 0) {
            ERROR(mLogCategory,"Error communicating with the wayland display");
            return ERROR_OPEN_FAIL;
        }
    }

    if (!mCompositor) {
        ERROR(mLogCategory,"Could not bind to wl_compositor. Either it is not implemented in " \
        "the compositor, or the implemented version doesn't match");
        return ERROR_OPEN_FAIL;
    }

    if (!mDmabuf) {
        ERROR(mLogCategory,"Could not bind to zwp_linux_dmabuf_v1");
        return ERROR_OPEN_FAIL;
    }

    if (!mXdgWmBase) {
        /* If wl_surface and wl_display are passed via GstContext
        * wl_shell, xdg_shell and zwp_fullscreen_shell are not used.
        * In this case is correct to continue.
        */
        ERROR(mLogCategory,"Could not bind to either wl_shell, xdg_wm_base or "
            "zwp_fullscreen_shell, video display may not work properly.");
        return ERROR_OPEN_FAIL;
    }

    //create window surface
    createCommonWindowSurface();
    createXdgShellWindowSurface();

    //config weston video plane
    if (mAmlConfigAPIList.enableSetVideoPlane) {
        INFO(mLogCategory,"set weston video plane:%d",mPip);
        wl_surface_set_video_plane(mVideoSurfaceWrapper, mPip);
    }

    //enable weston vsync callback
    if (mAmlConfigAPIList.enableVsyncCallback) {
        INFO(mLogCategory,"set vsync output id:%d",mSelectOutputIndex);
        aml_config_need_vsync_callback(mAmlConfig, mCompositor, mSelectOutputIndex);
    }

    if (mHideVideoChanged) {
        setHideVideo(mHideVideo);
    }

    //run wl display queue dispatch
    DEBUG(mLogCategory,"To run wl display dispatch queue");

    setThreadPriority(69);
    run("waylandProtocol");
    mRedrawingPending = false;
    mDisplayConnected = true;
    DEBUG(mLogCategory,"openDisplay out");
    return NO_ERROR;
}

void WaylandDisplay::closeDisplay()
{
    DEBUG(mLogCategory,"closeDisplay in");

    //first destroy window surface
    destroyWindowSurfaces();

    //flush pending event to weston
    if (mWlDisplay) {
        wl_display_flush (mWlDisplay);
    }

    //wait video surface destroyed or 50ms timeout
    if (mAmlConfigAPIList.enableSurfaceDestroyCallback) {
        INFO(mLogCategory,"waiting surface_destroy_cb from weston");
        if (mMutex.lock() == 0) { //success
            if (ERROR_TIMED_OUT == mCondition.waitRelative(mMutex, 50/*microsecond*/)) {
                WARNING(mLogCategory,"waited surface_destroy_cb timeout");
            }
            mMutex.unlock();
        }
    }

    //we should receive all event from weston before stopped dispatch queue
    if (isRunning()) {
        TRACE(mLogCategory,"try stop dispatch thread");
        if (mPoll) {
            mPoll->setFlushing(true);
        }
        requestExitAndWait();
    }
    //after destroyed surface,then destroy buffers,otherwise maybe crash
    if (mAreaShmBuffer) {
        delete mAreaShmBuffer;
        mAreaShmBuffer = NULL;
    }

    //clean all wayland buffers
    cleanAllWaylandBuffer();

    if (mViewporter) {
        wp_viewporter_destroy (mViewporter);
        mViewporter = NULL;
    }

    if (mShm) {
        wl_shm_destroy(mShm);
        mShm = NULL;
    }

    if (mDmabuf) {
        zwp_linux_dmabuf_v1_destroy (mDmabuf);
        mDmabuf = NULL;
    }

    if (mXdgWmBase) {
        xdg_wm_base_destroy (mXdgWmBase);
        mXdgWmBase = NULL;
    }

    if (mCompositor) {
        wl_compositor_destroy (mCompositor);
        mCompositor = NULL;
    }

    if (mSubCompositor) {
        wl_subcompositor_destroy (mSubCompositor);
        mSubCompositor = NULL;
    }

    if (mDirect_display) {
        weston_direct_display_v1_destroy(mDirect_display);
        mDirect_display = NULL;
    }

    for (int i = 0; i < DEFAULT_DISPLAY_OUTPUT_NUM; i++) {
        if (mOutput[i].wlOutput) {
            wl_output_destroy(mOutput[i].wlOutput);
        }
        mOutput[i].wlOutput = NULL;
    }

    if (mRegistry) {
        wl_registry_destroy (mRegistry);
        mRegistry= NULL;
    }

    if (mWlDisplayWrapper) {
        wl_proxy_wrapper_destroy (mWlDisplayWrapper);
        mWlDisplayWrapper = NULL;
    }

    if (mAmlConfig) {
        aml_config_destroy(mAmlConfig);
        mAmlConfig = NULL;
    }

    if (mWlQueue) {
        wl_event_queue_destroy (mWlQueue);
        mWlQueue = NULL;
    }

    if (mWlDisplay) {
        wl_display_flush (mWlDisplay);
        wl_display_disconnect (mWlDisplay);
        mWlDisplay = NULL;
    }

    /* Release deferred buffers after disconnecting from weston.
     * These buffers were in DISPLAYING/DISPLAYED state during cleanup;
     * weston no longer references them now that we've disconnected. */
    releaseDeferredBuffers();

    mDisplayConnected = false;
    //do not handle wayland client logs after disconnect
    if (mEnableWaylandClientLog) {
        wl_log_set_handler_client(NULL);
        mEnableWaylandClientLog = false;
    }

    mHideVideoChanged = false;
    mHideVideo = 0;
    //free all obtain buff
    TRACE(mLogCategory,"mCommittedBufferMap size:%d",mCommittedBufferMap.size());
    for (auto item = mCommittedBufferMap.begin(); item != mCommittedBufferMap.end(); ) {
        mCommittedBufferMap.erase(item++);
    }
    mCommittedBufferMap.clear();
    mDmaBufferFormats.clear();
    if (mPoll) {
        delete mPoll;
        mPoll = NULL;
    }
    DEBUG(mLogCategory,"closeDisplay out");
}

int WaylandDisplay::toDmaBufferFormat(RenderVideoFormat format, uint32_t *outDmaformat /*out param*/, uint64_t *outDmaformatModifiers /*out param*/)
{
    if (!outDmaformat || !outDmaformatModifiers) {
        WARNING(mLogCategory,"NULL params");
        return ERROR_PARAM_NULL;
    }

    *outDmaformat = 0;
    *outDmaformatModifiers = 0;

    uint32_t dmaformat = video_format_to_wl_dmabuf_format (format);
    if (dmaformat == -1) {
        ERROR(mLogCategory,"Error not found render video format:%d to wl dmabuf format",format);
        return ERROR_NOT_FOUND;
    }

    //TRACE(mLogCategory,"render video format:%d -> dmabuf format:%d",format,dmaformat);
    *outDmaformat = (uint32_t)dmaformat;

    /*get dmaformat and modifiers*/
    auto item = mDmaBufferFormats.find(dmaformat);
    if (item == mDmaBufferFormats.end()) { //not found
        WARNING(mLogCategory,"Not found dmabuf for render video format :%d",format);
        *outDmaformatModifiers = 0;
        return NO_ERROR;
    }

    *outDmaformatModifiers = (uint64_t)item->second;

    return NO_ERROR;
}

int WaylandDisplay::toShmBufferFormat(RenderVideoFormat format, uint32_t *outformat)
{
    if (!outformat) {
        WARNING(mLogCategory,"NULL params");
        return ERROR_PARAM_NULL;
    }

    *outformat = 0;

    int shmformat = (int)video_format_to_wl_shm_format(format);
    if (shmformat < 0) {
        ERROR(mLogCategory,"Error not found render video format:%d to wl shmbuf format",format);
        return ERROR_NOT_FOUND;
    }

    for (auto item = mShmFormats.begin(); item != mShmFormats.end(); ++item) {
        uint32_t  registFormat = (uint32_t)*item;
        if (registFormat == (uint32_t)shmformat) {
            *outformat = registFormat;
            return NO_ERROR;
        }
    }

    return ERROR_NOT_FOUND;
}

void WaylandDisplay::setVideoBufferFormat(RenderVideoFormat format)
{
    TRACE(mLogCategory,"set video buffer format: %d",format);
    mBufferFormat = format;
};

void WaylandDisplay::setDisplayOutput(int output)
{
    TRACE(mLogCategory,"select display output: %d",output);
    if (output < 0 || output >= DEFAULT_DISPLAY_OUTPUT_NUM) {
        ERROR(mLogCategory, "display output index error,please set 0:primary or 1:extend,now:%d",output);
        return;
    }
    //only do select output before video playing
    if (mSelectOutputIndex != output) {
        mSelectOutputIndex = output;
    }
}

int WaylandDisplay::getDisplayOutput()
{
    return mSelectOutputIndex == INVALID_OUTPUT_INDEX? 0: mSelectOutputIndex;
}

void WaylandDisplay::setPip(int pip)
{
    INFO(mLogCategory,"set pip:%d",pip);
    mPip = pip;
}

void WaylandDisplay::updateDisplayOutput()
{
    if (!mCurrentDisplayOutput->wlOutput || !mXdgToplevel || !mXdgSurface)
    {
        return;
    }
    if (mUpdateRenderRectangle) {
        if (mFullScreen) {
            DEBUG(mLogCategory,"unset full screen");
            xdg_toplevel_unset_fullscreen (mXdgToplevel);
        }

        if (mXdgSurface) {
            DEBUG(mLogCategory,"set geometry");
            xdg_surface_set_window_geometry(mXdgSurface,
                                            mCurrentDisplayOutput->offsetX,
                                            mCurrentDisplayOutput->offsetY,
                                            mCurrentDisplayOutput->width,
                                            mCurrentDisplayOutput->height);
        }

        if (mFullScreen && mXdgToplevel) {
            DEBUG(mLogCategory,"set full screen");
            xdg_toplevel_set_fullscreen (mXdgToplevel, mCurrentDisplayOutput->wlOutput);
        }
        setRenderRectangle(mCurrentDisplayOutput->offsetX, mCurrentDisplayOutput->offsetY,
                        mCurrentDisplayOutput->width, mCurrentDisplayOutput->height);
        mUpdateRenderRectangle = false;
    }
}

void WaylandDisplay::createCommonWindowSurface()
{
    struct wl_region *region;

    mAreaSurface = wl_compositor_create_surface (mCompositor);
    mVideoSurface = wl_compositor_create_surface (mCompositor);
    mAreaSurfaceWrapper = (struct wl_surface *)wl_proxy_create_wrapper (mAreaSurface);
    mVideoSurfaceWrapper = (struct wl_surface *)wl_proxy_create_wrapper (mVideoSurface);

    wl_proxy_set_queue ((struct wl_proxy *) mAreaSurfaceWrapper, mWlQueue);
    wl_proxy_set_queue ((struct wl_proxy *) mVideoSurfaceWrapper, mWlQueue);

    /* embed video_surface in area_surface */
    mVideoSubSurface = wl_subcompositor_get_subsurface (mSubCompositor, mVideoSurface, mAreaSurface);
    wl_subsurface_set_desync (mVideoSubSurface);

    //add video surface callback to weston if weston enable this feature
    if (mVideoSurface && mAmlConfigAPIList.enableSurfaceDestroyCallback) {
        struct wl_callback *surfaceDestroyCb = wl_surface_destroy_callback(mVideoSurface);
        wl_callback_add_listener(surfaceDestroyCb, &surface_destroy_listener, this);
    }

    if (mViewporter) {
        mAreaViewport = wp_viewporter_get_viewport (mViewporter, mAreaSurface);
        mVideoViewport = wp_viewporter_get_viewport (mViewporter, mVideoSurface);
    }

    /*set area surface to invisible. prevent frame droped at start playback,
    wl_surface_set_invisible must called before mAreaSurface commit called*/
    if (mAmlConfigAPIList.enableSetSurfaceInvisible) {
        int invisible = 1;
        INFO(mLogCategory,"set surface invisible:%d",invisible);
        wl_surface_set_invisible(mAreaSurfaceWrapper, invisible);
    }

    if (mAmlConfigAPIList.enableDisplayTime) {
        INFO(mLogCategory,"set enable display time");
        wl_surface_enable_display_time(mVideoSurface, 1);
    }

    if (mAmlConfigAPIList.enableSetPts) {
        INFO(mLogCategory,"add surface underflow listener");
        wl_surface_add_listener(mVideoSurface, &surface_listener, this);
    }

    /* do not accept input */
    region = wl_compositor_create_region (mCompositor);
    wl_surface_set_input_region (mAreaSurface, region);
    wl_region_destroy (region);

    region = wl_compositor_create_region (mCompositor);
    wl_surface_set_input_region (mVideoSurface, region);
    wl_region_destroy (region);
}

void WaylandDisplay::createXdgShellWindowSurface()
{
    /* Check which protocol we will use (in order of preference) */
    if (mXdgWmBase) {
        /* First create the XDG surface */
        mXdgSurface= xdg_wm_base_get_xdg_surface (mXdgWmBase, mAreaSurface);
        if (!mXdgSurface) {
            ERROR(mLogCategory,"Unable to get xdg_surface");
            return;
        }
        xdg_surface_add_listener (mXdgSurface, &xdg_surface_listener,(void *)this);

        /* Then the toplevel */
        mXdgToplevel= xdg_surface_get_toplevel (mXdgSurface);
        if (!mXdgSurface) {
            ERROR(mLogCategory,"Unable to get xdg_toplevel");
            return;
        }
        xdg_toplevel_add_listener (mXdgToplevel, &xdg_toplevel_listener, this);

        /* Finally, commit the xdg_surface state as toplevel */
        mXdgSurfaceConfigured = false;
        wl_surface_commit (mAreaSurface);
        wl_display_flush (mWlDisplay);
        /* we need exactly 3 roundtrips to discover global objects and their state */
        for (int i = 0; i < 3; i++) {
            if (wl_display_roundtrip_queue(mWlDisplay, mWlQueue) < 0) {
                ERROR(mLogCategory,"Error communicating with the wayland display");
            }
        }

        if (mXdgSurfaceConfigured) {
            INFO(mLogCategory,"xdg surface had configured");
        } else {
            WARNING(mLogCategory,"xdg surface not configured");
        }
    } else {
        ERROR(mLogCategory,"Unable to use xdg_wm_base ");
        return;
    }
}

void WaylandDisplay::destroyWindowSurfaces()
{
    if (mXdgToplevel) {
        xdg_toplevel_destroy (mXdgToplevel);
        mXdgToplevel = NULL;
    }

    if (mXdgSurface) {
        xdg_surface_destroy (mXdgSurface);
        mXdgSurface = NULL;
    }

    if (mVideoSurfaceWrapper) {
        wl_proxy_wrapper_destroy (mVideoSurfaceWrapper);
        mVideoSurfaceWrapper = NULL;
    }

    if (mVideoSubSurface) {
        wl_subsurface_destroy (mVideoSubSurface);
        mVideoSubSurface = NULL;
    }

    if (mVideoSurface) {
        wl_surface_destroy (mVideoSurface);
        mVideoSurface = NULL;
    }

    if (mAreaSurfaceWrapper) {
        wl_proxy_wrapper_destroy (mAreaSurfaceWrapper);
        mAreaSurfaceWrapper = NULL;
    }

    if (mAreaSurface) {
        wl_surface_destroy (mAreaSurface);
        mAreaSurface = NULL;
        mReCommitAreaSurface = false;
    }

    if (mAreaViewport) {
        wp_viewport_destroy(mAreaViewport);
        mAreaViewport = NULL;
    }

    if (mVideoViewport) {
        wp_viewport_destroy(mVideoViewport);
        mVideoViewport = NULL;
    }
}

void WaylandDisplay::ensureFullscreen(bool fullscreen)
{
    if (mXdgWmBase) {
        DEBUG(mLogCategory,"full screen : %d",fullscreen);
        if (fullscreen) {
            xdg_toplevel_set_fullscreen (mXdgToplevel, mCurrentDisplayOutput->wlOutput);
        } else {
            xdg_toplevel_unset_fullscreen (mXdgToplevel);
        }
    }
}

void WaylandDisplay::setRenderRectangle(int x, int y, int w, int h)
{
    DEBUG(mLogCategory,"set render rect:x:%d,y:%d,w:%d,h:%d",x,y,w,h);

    if (w <= 0 || h <= 0) {
        WARNING(mLogCategory, "wrong render width or height %dx%d",w,h);
        return;
    }

    mRenderRect.x = x;
    mRenderRect.y = y;
    mRenderRect.w = w;
    mRenderRect.h = h;
    /*if default transform is 1(90 degree) or 3（270 degree)
        or 5(flip and 90 degree) or 7(flip and 270 degree),transform w/h*/
    if (mVideoOnOSD &&
        (mDefaultTransform == 1 || mDefaultTransform == 3 || mDefaultTransform == 5 || mDefaultTransform == 7)) {
        mRenderRect.w = h;
        mRenderRect.h = w;
        DEBUG(mLogCategory,"transform %d,reset w:%d,h:%d",mDefaultTransform, mRenderRect.w, mRenderRect.h);
    }

    if (!mXdgSurfaceConfigured) {
        WARNING(mLogCategory,"Not configured xdg");
        return;
    }

    if (mAreaViewport) {
        wp_viewport_set_destination (mAreaViewport, mRenderRect.w, mRenderRect.h);
    }

    updateBorders();

    if (mVideoWidth != 0 && mVideoSurface) {
        wl_subsurface_set_sync (mVideoSubSurface);
        resizeVideoSurface(true);
    }

    wl_surface_damage (mAreaSurfaceWrapper, 0, 0, mRenderRect.w, mRenderRect.h);
    wl_surface_commit (mAreaSurfaceWrapper);

    if (mVideoWidth != 0) {
        wl_subsurface_set_desync (mVideoSubSurface);
    }
}

void WaylandDisplay::setFrameSize(int w, int h)
{
    mVideoWidth = w;
    mVideoHeight = h;
    mUpdateCropSize = true;
    INFO(mLogCategory,"frame w:%d,h:%d",mVideoWidth,mVideoHeight);
}

void WaylandDisplay::setWindowSize(int x, int y, int w, int h)
{
    mWindowRect.x = x;
    mWindowRect.y = y;
    mWindowRect.w = w;
    mWindowRect.h = h;
    INFO(mLogCategory,"window size:x:%d,y:%d,w:%d,h:%d",mWindowRect.x,mWindowRect.y,mWindowRect.w,mWindowRect.h);
    //if user set window size,force update window size
    if (mAmlConfigAPIList.enableForceUpdateRect &&
        mVideoSurfaceWrapper && mVideoWidth != 0) {
        if (mFullScreen) {
            mFullScreen = false;
            ensureFullscreen(mFullScreen);
        }
        resizeVideoSurface(false);
        //force weston update rectangle
        wl_surface_force_update_rect(mVideoSurfaceWrapper);
        wl_display_flush (mWlDisplay);
    } else {
        mUpdateVideoSurface = true;
    }
}

void WaylandDisplay::setCropSize(int x, int y, int w, int h)
{
    if (w <= 0 || h <= 0) {
        WARNING(mLogCategory, "wrong crop width or height %dx%d",w,h);
        return;
    }
    mCropRect.x = x;
    mCropRect.y = y;
    mCropRect.w = w;
    mCropRect.h = h;
    INFO(mLogCategory,"set crop window size:x:%d,y:%d,w:%d,h:%d",mCropRect.x,mCropRect.y,mCropRect.w,mCropRect.h);
    mUpdateCropSize = true;
}

void WaylandDisplay::setPixelAspectRatio(double ratio)
{
    //TRACE(mLogCategory,"pixel aspect ratio:%f",ratio);
    if (fabs(mPixelAspectRatio - ratio) > 0.001) {
        mUpdateVideoSurface = true;
    }
    mPixelAspectRatio = ratio;
}

void WaylandDisplay::configCropSize(int dma_width, int dma_height)
{
    if (mVideoViewport && mVideoHeight > 0 && mVideoWidth > 0 && dma_width > 0 && dma_height > 0) {
        int cx = mCropRect.x*dma_width/mVideoWidth;
        int cy = mCropRect.y*dma_height/mVideoHeight;
        int cw = mCropRect.w*dma_width/mVideoWidth;
        int ch = mCropRect.h*dma_height/mVideoHeight;

        if (cw > 0 && ch > 0) {
            INFO(mLogCategory,"set crop size:x:%d,y:%d,w:%d,h:%d to weston",cx,cy,cw,ch);

            wl_fixed_t fixed_t_x = wl_fixed_from_int(cx);
            wl_fixed_t fixed_t_y = wl_fixed_from_int(cy);
            wl_fixed_t fixed_t_w = wl_fixed_from_int(cw);
            wl_fixed_t fixed_t_h = wl_fixed_from_int(ch);
            wp_viewport_set_source(mVideoViewport, fixed_t_x,fixed_t_y,fixed_t_w,fixed_t_h);
            wl_display_flush (mWlDisplay);
        } else {
            INFO(mLogCategory,"warning crop size ,crop:(%d,%d,%d,%d) w:%d/%d,h:%d/%d",
                mCropRect.x, mCropRect.y, mCropRect.w, mCropRect.h,dma_width, mVideoWidth,dma_height, mVideoHeight);
        }
    } else {
        mUpdateCropSize = true;
    }
}

void WaylandDisplay::resizeVideoSurface(bool commit)
{
    Rectangle src = {0,};
    Rectangle dst = {0,};
    Rectangle res = {0,};

    /* center the video_subsurface inside area_subsurface */
    src.w = mVideoWidth;
    src.h = mVideoHeight;
    /*if had set the window size, we will scall
    video surface to this window size,do not limit window size*/
    if (mWindowRect.w > 0 && mWindowRect.h > 0) {
        dst.x = mWindowRect.x;
        dst.y = mWindowRect.y;
        dst.w = mWindowRect.w;
        dst.h = mWindowRect.h;
    } else { //scal video to full screen
        dst.w = mRenderRect.w;
        dst.h = mRenderRect.h;
    }

    /* 90/270 rotation window position check, dst window position updated
     * only hardware rotation is available */
    if (mVideoRotateDegree == 90 || mVideoRotateDegree == 270) {
        if (checkHWRotationAvailable()) {
            src.w = mVideoHeight;
            src.h = mVideoWidth;
            INFO(mLogCategory,"rotation %d degree src (%d,%d) -> (%d,%d)",mVideoRotateDegree,mVideoWidth, mVideoHeight, src.w, src.h);
        }
    }

    if (mKeepVideoAsptectRatio) {
        if (mViewporter) {
            videoCenterRect(src, dst, &res, true);
        } else {
            videoCenterRect(src, dst, &res, false);
        }
    } else {
        res.x = dst.x;
        res.y = dst.y;
        res.w = dst.w;
        res.h = dst.h;
    }

    if (mVideoSubSurface) {
        wl_subsurface_set_position (mVideoSubSurface, res.x, res.y);
    }

    if (mVideoSurfaceWrapper && commit) {
        wl_surface_damage (mVideoSurfaceWrapper, 0, 0, res.w, res.h);
        wl_surface_commit (mVideoSurfaceWrapper);
    }

    //top level setting
    if (mXdgToplevel) {
        struct wl_region *region;

        region = wl_compositor_create_region (mCompositor);
        wl_region_add (region, 0, 0, mRenderRect.w, mRenderRect.h);
        wl_surface_set_input_region (mAreaSurface, region);
        wl_region_destroy (region);
    }

    /* this is saved for use in wl_surface_damage */
    mVideoRect.x = res.x;
    mVideoRect.y = res.y;
    mVideoRect.w = res.w;
    mVideoRect.h = res.h;

    //to scale video surface
    if (mVideoViewport) {
        wp_viewport_set_destination(mVideoViewport, res.w, res.h);
        wl_display_flush (mWlDisplay);
    }
    TRACE(mLogCategory,"video rectangle,x:%d,y:%d,w:%d,h:%d",mVideoRect.x, mVideoRect.y, mVideoRect.w, mVideoRect.h);
}

void WaylandDisplay::setOpaque()
{
    struct wl_region *region;

    /* Set area opaque */
    if (mCompositor) {
        region = wl_compositor_create_region (mCompositor);
        wl_region_add (region, 0, 0, mRenderRect.w, mRenderRect.h);
        wl_surface_set_opaque_region (mAreaSurface, region);
        wl_region_destroy (region);
    }
}

int  WaylandDisplay::prepareFrameBuffer(RenderBuffer * buf)
{
    WaylandBuffer *waylandBuf = NULL;
    int ret = NO_ERROR;
    bool isNew = false;
    if (!mWlDisplay || !mDisplayConnected) {
        ERROR(mLogCategory,"Error disconnected from weston %s", mWlDisplay == NULL?"mWlDisplay is NULL":" ");
        return ERROR_UNKNOWN;
    }

    if (buf->flag & BUFFER_FLAG_LAST_EMPTY_BUFFER) {
        mWaylandBufferCookieId += 1;
        DEBUG(mLogCategory,"drs, get last buffer, update cookie:%d",mWaylandBufferCookieId);
        if (DUMP_WAYLAND_BUFFER_LOG) {
            dumpAllWaylandBuffer();
        }
        cleanWaylandBufferBeforeResChanged();
        return NO_ERROR;
    }
    if (DUMP_WAYLAND_BUFFER_LOG) {
        DEBUG(mLogCategory,"pts:%lld us w:%d,h:%d",buf->pts/1000, buf->dma.width,buf->dma.height);
    }
    //detect frame rate and frame duration
    if (mFrameRateFractionNum == 0) {
        if (mPreFramePts == -1) {
            mPreFramePts = buf->pts; //ns
        } else {
            if (mFrameRateDetectCnt < DETECT_FRAMERATE_CNT) {
                mFrameRateDetectPeriod += (buf->pts - mPreFramePts);
                ++mFrameRateDetectCnt;
            }
            if (mFrameRateDetectCnt == DETECT_FRAMERATE_CNT) {
                int64_t mFrameDurationUs = (mFrameRateDetectPeriod/mFrameRateDetectCnt)/1000;
                double rate = 1000000.0/mFrameDurationUs;
                mFrameRateFractionNum = rate * 100;
                mFrameRateFractionDenom = 100;
                mFrameRateChanged = true;
                INFO(mLogCategory,"detect frame num:%d,denom:%d,dur:%lld us",
                    mFrameRateFractionNum,mFrameRateFractionDenom,mFrameDurationUs);
            }
        }
    }
    mPreFramePts = buf->pts;

    if (!mDmabuf)
    {
        ERROR(mLogCategory,"Error zwp_linux_dmabuf_v1");
        return ERROR_UNKNOWN;
    }
    //prepare frame with and height
    if ((mPrepareFrameWidth == 0 || mPrepareFrameHeight == 0) &&
        buf->dma.width > 0) {
        mPrepareFrameWidth = buf->dma.width;
        mPrepareFrameHeight = buf->dma.height;
    }
    //if resolution changed,update waylandbuffer cookie id
    if (mPrepareFrameWidth != buf->dma.width ||
        mPrepareFrameHeight != buf->dma.height) {
        mWaylandBufferCookieId += 1;
        DEBUG(mLogCategory,"drs,pts:%lld us,w:%d,h:%d,update cookie:%d",buf->pts/1000,buf->dma.width,buf->dma.height,mWaylandBufferCookieId);
    }
    //TRACE(mLogCategory,"renderbuf:%p,pts:%lld us,w:%d,h:%d,cookie:%d",buf,buf->pts/1000,buf->dma.width,buf->dma.height,mWaylandBufferCookieId);

    waylandBuf = findWaylandBuffer(buf);
    if (waylandBuf == NULL || waylandBuf->getCookieId() != mWaylandBufferCookieId) {
        /*When the fps changes, sometimes the hash value of the dmabuffer is the same as that of the previous buffer.
        we should free previous wayland buffer*/
        if (waylandBuf && waylandBuf->isFree()) {
            removeWaylandBuffer(buf);
            delete waylandBuf;
            waylandBuf = NULL;
        }
        waylandBuf = new WaylandBuffer(this, mLogCategory, mWaylandBufferCookieId);
        isNew = true;
    }
    waylandBuf->setBufferFormat(mBufferFormat);
    ret = waylandBuf->constructWlBuffer(buf);
    if (ret != NO_ERROR) {
        WARNING(mLogCategory,"dmabufConstructWlBuffer fail");
    }

    mPrepareFrameWidth = buf->dma.width;
    mPrepareFrameHeight = buf->dma.height;

    if (isNew) {
        addWaylandBuffer(buf, waylandBuf);
    }
    return NO_ERROR;
}

void WaylandDisplay::displayFrameBuffer(RenderBuffer * buf, int64_t realDisplayTime)
{
    WaylandBuffer *waylandBuf = NULL;
    struct wl_buffer * wlbuffer = NULL;
    int ret = NO_ERROR;

    if (!buf) {
        ERROR(mLogCategory,"Error input params, RenderBuffer is null");
        return;
    }

    if (!mWlDisplay || !mDisplayConnected) {
        ERROR(mLogCategory,"Error disconnect from weston %s", mWlDisplay == NULL?"mWlDisplay is NULL":" ");
        goto waylandbuf_fail;
    }

    if (buf->flag & BUFFER_FLAG_LAST_EMPTY_BUFFER) {
        int num = 0;
        DEBUG(mLogCategory,"drs, last buffer, cookie:%d",mWaylandBufferCookieId);
        mWaylandPlugin->handleBufferRelease(buf);
        /*clean prepared waylandbuffers but dropped,
        we should force buffer state to idle and clean it*/
        {
            ATools::Mutex::Autolock _l(mBufferMutex);
            for (auto item = mWaylandBuffersMap.begin(); item != mWaylandBuffersMap.end(); ) {
                WaylandBuffer *wlbuf = (WaylandBuffer*)item->second;
                if (wlbuf->getCookieId() < mWaylandBufferCookieId && wlbuf->getBufferState() == BUFFER_PREPARED) {
                    wlbuf->forceBufferStateIdle();
                }
                item++;
            }
        }
        num = cleanWaylandBufferBeforeResChanged();
        if (num > 0) {
            mUpdateWaylandBuffersMap = true;
        } else {
            mUpdateWaylandBuffersMap = false;
        }
        if (DUMP_WAYLAND_BUFFER_LOG) {
            dumpAllWaylandBuffer();
        }
        return;
    }
    if ((mDisplayedFrameWidth == 0 || mDisplayedFrameHeight == 0) &&
        buf->dma.width > 0) {
        mDisplayedFrameWidth = buf->dma.width;
        mDisplayedFrameHeight = buf->dma.height;
        mUpdateVideoSurface = true;
    }

    if (buf->flag & BUFFER_FLAG_DMA_BUFFER) {
        if (buf->dma.width <=0 || buf->dma.height <=0) {
            buf->dma.width = mVideoWidth;
            buf->dma.height = mVideoHeight;
        }

        waylandBuf = findWaylandBuffer(buf);
        if (waylandBuf) {
            waylandBuf->setRenderRealTime(realDisplayTime);
        } else {
            ERROR(mLogCategory,"NOT found wayland buffer,please prepare buffer first");
            goto waylandbuf_fail;
        }
    }

    //if no wl_output, drop this buffer
    if (mCurrentDisplayOutput->wlOutput == NULL) {
        TRACE(mLogCategory,"No wl_output");
        mRenderMutex.lock();
        //insert this buffer to committed weston buffer manager
        std::pair<int64_t, WaylandBuffer *> item(realDisplayTime, waylandBuf);
        mCommittedBufferMap.insert(item);
        mRenderMutex.unlock();
        mWaylandPlugin->handleFrameDropped(buf);
        WaylandBuffer::bufferRelease(waylandBuf,NULL);
        return;
    }

    //must commit areasurface first, because weston xdg surface maybe timeout
    //this cause video is not display,commit can resume xdg surface
    if (!mReCommitAreaSurface) {
        mReCommitAreaSurface = true;
        wl_surface_commit (mAreaSurface);
    }

    //set frame rate to weston,it lets weston to select suitable mode
    if (mFrameRateChanged && mAmlConfigAPIList.enableSetDisplayRate) {
        mFrameRateChanged = false;
        TRACE(mLogCategory,"set frame rate %d/%d to weston", mFrameRateFractionNum, mFrameRateFractionDenom);
        wl_surface_set_display_rate(mVideoSurfaceWrapper, mFrameRateFractionNum, mFrameRateFractionDenom);
        //get dpss latency from weston
        if (mAmlConfigAPIList.enableDpss) {
            int fr = mFrameRateFractionNum * 1000/mFrameRateFractionDenom;
            if (fr <= 0) {
                fr = 60000;
            }
            TRACE(mLogCategory,"get dpss latency from weston");
            aml_config_get_dpss_latency(mAmlConfig, mCompositor, fr, mSelectOutputIndex);
        }
    }
    //resolution changed,update video surface size
    if (buf->dma.width != mDisplayedFrameWidth || buf->dma.height != mDisplayedFrameHeight) {
        mUpdateVideoSurface = true;
        mUpdateCropSize = true;
        mUpdateWaylandBuffersMap = true;
    }
    //update video crop size
    if (mUpdateCropSize && mVideoViewport) {
        mUpdateCropSize = false;
        if (!mAmlConfigAPIList.enableNeedOriginalSize) {
            configCropSize(buf->dma.width, buf->dma.height);
        } else {
            configCropSize(mVideoWidth, mVideoHeight);
        }
    }
    //update video surface size
    if (mUpdateVideoSurface && mVideoSurface) {
        mUpdateVideoSurface = false;
        //if had full screen, unset it and set window size
        if (mFullScreen) {
            mFullScreen = false;
            ensureFullscreen(mFullScreen);
        }
        /*don't wl_surface_commit when we ready to post buffer to weston.
        wl_surface_commit before post buffer makes weston mistake it for
        a new frame submission
        */
        resizeVideoSurface(false);
    }

    if (mVideoPlaneZorderChanged && mVideoSurfaceWrapper) {
        mVideoPlaneZorderChanged = false;
        //only set zorder to area surface when doing osd displayed
        if (mVideoOnOSD) {
            wl_surface_set_zorder(mAreaSurfaceWrapper, mVideoPlaneZorder);
        }
        wl_surface_set_zorder(mVideoSurfaceWrapper, mVideoPlaneZorder);
    }

    //TRACE(mLogCategory,"display renderBuffer:%p,PTS:%lld us,realtime:%lld",buf, buf->pts/1000, realDisplayTime);

    if (waylandBuf) {
        wlbuffer = waylandBuf->getWlBuffer();
    }

    if (wlbuffer) {
        ATools::Mutex::Autolock _l(mRenderMutex);
        auto cItem = mCommittedBufferMap.find(realDisplayTime);
        if (cItem != mCommittedBufferMap.end()) {
            TRACE(mLogCategory,"Error.release same display time buffer,pts:%lld us",buf->pts/1000);
            goto waylandbuf_fail;
        }
        //if renderbuffer in WaylandBuffer is null, construct it
        if (!waylandBuf->getRenderBuffer()) {
            ret = waylandBuf->constructWlBuffer(buf);
            if (ret != NO_ERROR) {
                WARNING(mLogCategory,"waylandBuf construct failed");
                goto waylandbuf_fail;
            }
        }

        // some DTV case will wait for first frame signal to unmute video
        // we need report first frame signal in advance before attach the frame
        // otherwise, it may cause weston mute video until several frames attached
        if (!mSignalFirstFramePts && mFirstFramePts == INVALID_PTS && mCommitCnt == 0) {
            mSignalFirstFramePts = true;
            INFO(mLogCategory,"signalFirstFrame:%lld ns",buf->pts);
            mWaylandPlugin->handleMsgNotify(MSG_FIRST_FRAME, (void*)&buf->pts);
        }
        ++mCommitCnt;
        uint32_t hiPts = realDisplayTime >> 32;
        uint32_t lowPts = realDisplayTime & 0xFFFFFFFF;
        //attach this wl_buffer to weston
        DEBUG(mLogCategory,"++attach,renderbuf:%p(%p),fd(%d,%d),wl_buffer:%p(%d,%d,%d,%d),pts:%lld us(%lld),commitCnt:%d",
            buf,waylandBuf,buf->dma.fd[0],buf->dma.fd[1],wlbuffer,mVideoRect.x,mVideoRect.y,mVideoRect.w,mVideoRect.h,buf->pts/1000,realDisplayTime,mCommitCnt);
        waylandBuf->attach(mVideoSurfaceWrapper);

        if (mAmlConfigAPIList.enableSetPts) {
            //TRACE(mLogCategory,"display time:%lld,hiPts:%u,lowPts:%u",realDisplayTime, hiPts, lowPts);
            wl_surface_set_pts(mVideoSurfaceWrapper, hiPts, lowPts);
        }
        //record first pts after mute video when flush
        if (!mKeepFrameOnFlush && mMuteVideoOnFlush && mFirstPtsAfterFlush == INVALID_PTS) {
            mFirstPtsAfterFlush = buf->pts;
            DEBUG(mLogCategory,"mFirstPtsAfterFlush,pts:%lld us",mFirstPtsAfterFlush);
        }

        if (mFirstFramePts == INVALID_PTS) {
            mFirstFramePts = buf->pts;
            DEBUG(mLogCategory,"mFirstFramePts,pts:%lld ns",mFirstFramePts);
        }

        //doing video rotate if needed
        if (mVideoRotateDegree >= 0) {
            /*weston accept degree map: transfer value->degree, 0->0, 1->90,2->180,3->270
            detail see: enum wl_output_transform or search WL_OUTPUT_TRANSFORM_xxx*/
            int transform = 0;
            switch (mVideoRotateDegree) {
                case 90: {
                    transform = 1;
                } break;
                case 180: {
                    transform = 2;
                } break;
                case 270: {
                    transform = 3;
                } break;
                default:
                    transform = 0;
            }
            DEBUG(mLogCategory,"set transform to weston:%d",transform);
            wl_surface_set_buffer_transform(mVideoSurfaceWrapper, transform);
        }

        wl_surface_damage (mVideoSurfaceWrapper, 0, 0, mVideoRect.w, mVideoRect.h);
        wl_surface_commit (mVideoSurfaceWrapper);
        mDisplayedFrameWidth = buf->dma.width;
        mDisplayedFrameHeight = buf->dma.height;
        //insert this buffer to committed weston buffer manager
        std::pair<int64_t, WaylandBuffer *> item(realDisplayTime, waylandBuf);
        mCommittedBufferMap.insert(item);
    } else {
        WARNING(mLogCategory,"wlbuffer is NULL,pts:%lld us",buf->pts/1000);
        goto waylandbuf_fail;
    }

    wl_display_flush (mWlDisplay);
    //set keep last frame or not when after send first buffer to weston,1 keep last frame, 0 not
    if (mToSendKeepLastFrame) {
        setKeepLastFrame(mKeepLastFrame);
    }

    /**
     * 1.clean released buffers by weston,these buffers had displayed and released
     * 2.some buffer dropped before committed to weston, force these buffer to idle
     * state and clean them
     */
    if (mUpdateWaylandBuffersMap) {
        int num = 0;
        /*if waylandBuf's cookie reached mWaylandBufferCookieId,
        those buffers allocated before waylandBuf had displayed, if
        buffer state is prepared,maybe this buffer dropped.
        we should force buffer state to idle and clean it*/
        if (waylandBuf->getCookieId() == mWaylandBufferCookieId) {
            ATools::Mutex::Autolock _l(mBufferMutex);
            for (auto item = mWaylandBuffersMap.begin(); item != mWaylandBuffersMap.end(); ) {
                WaylandBuffer *wlbuf = (WaylandBuffer*)item->second;
                if (wlbuf->getCookieId() < mWaylandBufferCookieId && wlbuf->getBufferState() == BUFFER_PREPARED) {
                    wlbuf->forceBufferStateIdle();
                }
                item++;
            }
        }
        num = cleanWaylandBufferBeforeResChanged();
        if (num > 0) {
            mUpdateWaylandBuffersMap = true;
        } else {
            mUpdateWaylandBuffersMap = false;
        }
        if (DUMP_WAYLAND_BUFFER_LOG) {
            dumpAllWaylandBuffer();
        }
    }

    return;
waylandbuf_fail:
    //notify dropped
    mWaylandPlugin->handleFrameDropped(buf);
    //notify app release this buf
    mWaylandPlugin->handleBufferRelease(buf);
    if (waylandBuf) {
        if (waylandBuf->getCookieId() < mWaylandBufferCookieId && waylandBuf->getBufferState() == BUFFER_PREPARED) {
            waylandBuf->forceBufferStateIdle();
            cleanWaylandBufferBeforeResChanged();
            if (DUMP_WAYLAND_BUFFER_LOG) {
                dumpAllWaylandBuffer();
            }
        }
    }
    return;
}

void WaylandDisplay::handleBufferReleaseCallback(WaylandBuffer *buf)
{
    RenderBuffer *renderBuffer = buf->getRenderBuffer();
    {
        ATools::Mutex::Autolock _l(mRenderMutex);
        //remove buffer if this buffer is ready to release
        auto item = mCommittedBufferMap.find(buf->getRenderRealTime());
        if (item != mCommittedBufferMap.end()) {
            --mCommitCnt;
            mCommittedBufferMap.erase(buf->getRenderRealTime());
        } else {
            if (renderBuffer) {
                TRACE(mLogCategory,"Error,Can't find WaylandBuffer pts:%lld us (%lld) in buffer map %p",
                    renderBuffer->pts/1000,buf->getRenderRealTime(),renderBuffer);
            }
            return;
        }
    }

    DEBUG(mLogCategory,"renderBuffer :%p,fd(%d,%d)priv:%p,PTS:%lld us,realtime:%lld us,commitCnt:%d",
        renderBuffer,renderBuffer->dma.fd[0],renderBuffer->dma.fd[1],renderBuffer->priv,renderBuffer->pts/1000,buf->getRenderRealTime(),mCommitCnt);
    mWaylandPlugin->handleBufferRelease(renderBuffer);
}

void WaylandDisplay::handleFrameDisplayedCallback(WaylandBuffer *buf)
{
    RenderBuffer *renderBuffer = buf->getRenderBuffer();
    DEBUG(mLogCategory,"renderBuffer:%p,PTS:%lld us,realtime:%lld us",renderBuffer,renderBuffer->pts/1000,buf->getRenderRealTime());
    if (!mSignalFirstFramePts && mFirstFramePts != INVALID_PTS && renderBuffer->pts >= mFirstFramePts) {
        mSignalFirstFramePts = true;
        INFO(mLogCategory,"signalFirstFrame:%lld ns",renderBuffer->pts);
        mWaylandPlugin->handleMsgNotify(MSG_FIRST_FRAME, (void*)&renderBuffer->pts);
    }
    if (!mAmlConfigAPIList.enableSetPts) {
        mWaylandPlugin->signalWaitTimeout();
    }
    mWaylandPlugin->handleFrameDisplayed(renderBuffer);
    if (!mKeepFrameOnFlush && mMuteVideoOnFlush &&
        mFirstPtsAfterFlush != INVALID_PTS && mFirstPtsAfterFlush <= renderBuffer->pts) {
        mFirstPtsAfterFlush = INVALID_PTS;
        mMuteVideoOnFlush = false;
        wl_surface_set_video_plane_mute(mVideoSurfaceWrapper, 0);
        INFO(mLogCategory,"unmute video");
    }
}

void WaylandDisplay::handleFrameDropedCallback(WaylandBuffer *buf)
{
    RenderBuffer *renderBuffer = buf->getRenderBuffer();
    DEBUG(mLogCategory,"renderBuffer :%p,PTS:%lld us,realtime:%lld us",renderBuffer,renderBuffer->pts/1000,buf->getRenderRealTime());
    mWaylandPlugin->handleFrameDropped(renderBuffer);
}

void WaylandDisplay::handleFrameTime(WaylandBuffer *buf,uint32_t sec, uint32_t usec)
{
    RenderBuffer *renderBuffer = buf->getRenderBuffer();

    handleFrameDisplayedCallback(buf);

    int64_t frameDisplayTimeUs = int64_t(sec)*1000000LL + usec;
    if (mLastDisplayFramePts == -1) {
        mLastDisplayFramePts = renderBuffer->pts;
        mLastDisplayFrameTimeUs = frameDisplayTimeUs;
    } else { //calculate last frame displayed duration
        int64_t duration = frameDisplayTimeUs - mLastDisplayFrameTimeUs;
        TRACE(mLogCategory,"now pts:%lld us,last dur:%lld us,time:%u us",
            renderBuffer->pts/1000,duration,frameDisplayTimeUs);
        if (mFrameDurationUs > 0 && duration > FRAME_FREEZE_THRESHOLD(mFrameDurationUs)) {
            FrameDisplayInfo frameDisplayInfo = {-1, -1};
            frameDisplayInfo.pts = mLastDisplayFramePts;
            frameDisplayInfo.duration = duration;
            INFO(mLogCategory,"reportFreezeFrame,pts:%lld us,dur:%lld us",frameDisplayInfo.pts/1000,frameDisplayInfo.duration);
            mWaylandPlugin->handleMsgNotify(MSG_FRAME_FREEZE, &frameDisplayInfo);
        }
        mLastDisplayFramePts = renderBuffer->pts;
        mLastDisplayFrameTimeUs = frameDisplayTimeUs;
    }
}


void WaylandDisplay::readyToRun()
{
    mFd = wl_display_get_fd (mWlDisplay);
    if (mPoll) {
        mPoll->addFd(mFd);
        mPoll->setFdReadable(mFd, true);
    }
}

void WaylandDisplay::readyToExit()
{
    if (mPoll && mFd >= 0) {
        mPoll->removeFd(mFd);
    }
}

bool WaylandDisplay::threadLoop()
{
    int ret;

    while (wl_display_prepare_read_queue (mWlDisplay, mWlQueue) != 0) {
      wl_display_dispatch_queue_pending (mWlDisplay, mWlQueue);
    }

    wl_display_flush (mWlDisplay);

    /*poll timeout value must > 300 ms,otherwise zwp_linux_dmabuf will create failed,
     so do use -1 to wait for ever*/
    ret = mPoll->wait(-1); //wait for ever
    if (ret < 0) { //poll error
        WARNING(mLogCategory,"poll error");
        wl_display_cancel_read(mWlDisplay);
        return false;
    } else if (ret == 0) { //poll time out
        return true; //run loop
    }

    if (wl_display_read_events (mWlDisplay) == -1) {
        ERROR(mLogCategory,"Error communicating with the wayland server");
        mDisplayConnected = false;
        return false;
    }

    wl_display_dispatch_queue_pending (mWlDisplay, mWlQueue);
    return true;
}

void WaylandDisplay::videoCenterRect(Rectangle src, Rectangle dst, Rectangle *result, bool scaling)
{
    //if dst is a small window, we scale video to map window size,don't doing center
    // if (mRenderRect.w != dst.w && mRenderRect.h != dst.h) {
    //     result->x = dst.x;
    //     result->y = dst.y;
    //     result->w = dst.w;
    //     result->h = dst.h;
    //     TRACE(mLogCategory,"small window source is %dx%d dest is %dx%d, result is %d,%d,%d,%d",
    //     src.w, src.h, dst.w, dst.h, result->x, result->y, result->w, result->h);
    //     return;
    // }
    if (!scaling) {
        result->w = MIN (src.w, dst.w);
        result->h = MIN (src.h, dst.h);
        result->x = dst.x + (dst.w - result->w) / 2;
        result->y = dst.y + (dst.h - result->h) / 2;
    } else {
        double src_ratio, dst_ratio;

        src_ratio = (double) (src.w * mPixelAspectRatio) / src.h;
        dst_ratio = (double) dst.w / dst.h;

        if (src_ratio > dst_ratio) {
            result->w = dst.w;
            result->h = dst.w / src_ratio;
            result->x = dst.x;
            result->y = dst.y + (dst.h - result->h) / 2;
        } else if (src_ratio < dst_ratio) {
            result->w = dst.h * src_ratio;
            result->h = dst.h;
            result->x = dst.x + (dst.w - result->w) / 2;
            result->y = dst.y;
        } else {
            result->x = dst.x;
            result->y = dst.y;
            result->w = dst.w;
            result->h = dst.h;
        }
    }

    DEBUG(mLogCategory,"source is %dx%d dest is %dx%d, result is %d,%d,%d,%d",
        src.w, src.h, dst.w, dst.h, result->x, result->y,result->w, result->h);
}

void WaylandDisplay::updateBorders()
{
    int width = 0;
    int height = 0;

    if (mNoBorderUpdate)
        return;

    if (mViewporter) {
        width = height = 1;
        mNoBorderUpdate = true;
    } else {
        width = mRenderRect.w;
        height = mRenderRect.h;
    }

    RenderVideoFormat format = VIDEO_FORMAT_BGRA;
    mAreaShmBuffer = new WaylandShmBuffer(this, mLogCategory);
    struct wl_buffer *wlbuf = mAreaShmBuffer->constructAreaShmWlBuffer(width, height, format);
    if (wlbuf == NULL) {
        delete mAreaShmBuffer;
        mAreaShmBuffer = NULL;
    }
    if (mAreaSurfaceWrapper) {
        wl_surface_attach(mAreaSurfaceWrapper, wlbuf, 0, 0);
    }
}

std::size_t WaylandDisplay::calculateDmaBufferHash(RenderDmaBuffer &dmabuf)
{
    std::string hashString("");
    for (int i = 0; i < dmabuf.planeCnt; i++) {
        char hashtmp[1024];
        snprintf (hashtmp, 1024, "%d%d%d%d%d%d%d%d",i,dmabuf.width,dmabuf.height,dmabuf.planeCnt,
                dmabuf.stride[i],dmabuf.offset[i],dmabuf.fd[i],dmabuf.handle[i]);
        std::string tmp(hashtmp);
        hashString += tmp;
    }

    std::size_t hashval = std::hash<std::string>()(hashString);
    if (DUMP_WAYLAND_BUFFER_LOG) {
        TRACE(mLogCategory,"hashstr:%s,val:%zu",hashString.c_str(),hashval);
    }
    return hashval;
}

void WaylandDisplay::addWaylandBuffer(RenderBuffer * buf, WaylandBuffer *waylandbuf)
{
    ATools::Mutex::Autolock _l(mBufferMutex);
    if (buf->flag & BUFFER_FLAG_DMA_BUFFER) {
        std::size_t hashval = calculateDmaBufferHash(buf->dma);
        std::pair<std::size_t, WaylandBuffer *> item(hashval, waylandbuf);
        if (DUMP_WAYLAND_BUFFER_LOG) {
            TRACE(mLogCategory,"fd[0]:%d,fd[1]:%d,w:%d,h:%d,%p,hash:%zu",buf->dma.fd[0],buf->dma.fd[1],buf->dma.width,buf->dma.height,waylandbuf,hashval);
        }
        mWaylandBuffersMap.insert(item);
    }
    TRACE(mLogCategory,"mWaylandBuffersMap size:%d",mWaylandBuffersMap.size());
    if (DUMP_WAYLAND_BUFFER_LOG) {
        dumpAllWaylandBuffer();
    }
}

WaylandBuffer* WaylandDisplay::findWaylandBuffer(RenderBuffer * buf)
{
    ATools::Mutex::Autolock _l(mBufferMutex);
    std::size_t hashval = calculateDmaBufferHash(buf->dma);
    auto item = mWaylandBuffersMap.find(hashval);
    if (item == mWaylandBuffersMap.end()) {
        return NULL;
    }

    return (WaylandBuffer*) item->second;
}

void WaylandDisplay::removeWaylandBuffer(RenderBuffer * buf)
{
    ATools::Mutex::Autolock _l(mBufferMutex);
    std::size_t hashval = calculateDmaBufferHash(buf->dma);
    auto item = mWaylandBuffersMap.find(hashval);
    if (item == mWaylandBuffersMap.end()) {
        return ;
    }

    mWaylandBuffersMap.erase(item);
}

void WaylandDisplay::cleanAllWaylandBuffer()
{
    ATools::Mutex::Autolock _l(mBufferMutex);
    //free all obtain buff
    for (auto item = mWaylandBuffersMap.begin(); item != mWaylandBuffersMap.end(); ) {
        WaylandBuffer *waylandbuf = (WaylandBuffer*)item->second;
        /* If buffer is still held by weston (DISPLAYING or DISPLAYED state),
         * defer the buffer release callback until after wl_display_disconnect.
         * weston may still be using these buffers; releasing them prematurely
         * could cause the upstream plugin to reuse a buffer weston still reads. */
        if ((waylandbuf->getBufferState() == BUFFER_DISPLAYING ||
             waylandbuf->getBufferState() == BUFFER_DISPLAYED) &&
             waylandbuf->getRenderBuffer()) {
            mDeferredReleaseBuffers.push_back(waylandbuf->getRenderBuffer());
            waylandbuf->forceBufferStateIdle(); // sets state to IDLE, clears mRenderBuffer
        }
        mWaylandBuffersMap.erase(item++);
        delete waylandbuf;
    }
    mWaylandBuffersMap.clear();
}

void WaylandDisplay::releaseDeferredBuffers()
{
    for (auto buf : mDeferredReleaseBuffers) {
        INFO(mLogCategory,"release deferred buffer:%p,pts:%lld us", buf, buf->pts/1000);
        mWaylandPlugin->handleBufferRelease(buf);
    }
    mDeferredReleaseBuffers.clear();
}

void WaylandDisplay::dumpAllWaylandBuffer() {
    INFO(mLogCategory,"mWaylandBuffersMap size:%d",mWaylandBuffersMap.size());
    for (auto item = mWaylandBuffersMap.begin(); item != mWaylandBuffersMap.end(); ) {
        WaylandBuffer *wlbuf = (WaylandBuffer*)item->second;
        std::size_t hashVal = item->first;
        item++;
        INFO(mLogCategory,"WaylandBuffer:%p, hash:%zu, state:%d, cookie:%d, %dx%d",
            wlbuf,hashVal,wlbuf->getBufferState(),wlbuf->getCookieId(),wlbuf->getFrameWidth(),wlbuf->getFrameHeight());
    }
}

/**
 * @brief clean wayland buffers those malloc before resolution changed
 *
 */
int WaylandDisplay::cleanWaylandBufferBeforeResChanged()
{
    int num = 0;
    ATools::Mutex::Autolock _l(mBufferMutex);
    for (auto item = mWaylandBuffersMap.begin(); item != mWaylandBuffersMap.end(); ) {
        WaylandBuffer *wlbuf = (WaylandBuffer*)item->second;
        std::size_t hashVal = item->first;
        if (wlbuf->isFree()) {
            mWaylandBuffersMap.erase(item++);
            delete wlbuf;
        } else {
            item++;
            if (wlbuf->getCookieId() < mWaylandBufferCookieId) {
                num++;
                TRACE(mLogCategory,"left WaylandBuffer:%p, hash:%zu, state:%d, cookie:%d, %dx%d",
                wlbuf,hashVal,wlbuf->getBufferState(),wlbuf->getCookieId(),wlbuf->getFrameWidth(),wlbuf->getFrameHeight());
            }
        }
    }
    return num;
}

void WaylandDisplay::flushBuffers()
{
    INFO(mLogCategory,"flushBuffers");
    if (mVideoSurfaceWrapper && !mKeepFrameOnFlush) {
        INFO(mLogCategory,"mute video");
        mMuteVideoOnFlush = true;
        mFirstPtsAfterFlush = INVALID_PTS;
        wl_surface_set_video_plane_mute(mVideoSurfaceWrapper, 1);
    }
    /*buffers obtained by weston will displayed,so we don't force to do display callback*/
    // ATools::Mutex::Autolock _l(mRenderMutex);
    // for (auto item = mCommittedBufferMap.begin(); item != mCommittedBufferMap.end(); item++) {
    //     WaylandBuffer *waylandbuf = (WaylandBuffer*)item->second;
    //     waylandbuf->forceRedrawing();
    //     handleFrameDisplayedCallback(waylandbuf);
    // }
    mSignalFirstFramePts = false;
    mFirstFramePts = INVALID_PTS;
}

void WaylandDisplay::cleanSurface()
{
    /* clear both video and parent surfaces */
    wl_surface_attach (mVideoSurfaceWrapper, NULL, 0, 0);
    wl_surface_commit (mVideoSurfaceWrapper);
    wl_surface_attach (mAreaSurfaceWrapper, NULL, 0, 0);
    wl_surface_commit (mAreaSurfaceWrapper);
}

void WaylandDisplay::setKeepLastFrame(int keep)
{
    mKeepLastFrame = keep;
    if (mVideoSurfaceWrapper && mAmlConfigAPIList.enableKeepLastFrame) {
        INFO(mLogCategory,"keep last frame:%d",keep);
        wl_surface_keep_last_frame(mVideoSurfaceWrapper, keep);
        mToSendKeepLastFrame = false;
        return;
    }
    mToSendKeepLastFrame = true;
}

void WaylandDisplay::setKeepLastFrameOnFlush(int keepOnFlush)
{
    mKeepFrameOnFlush = keepOnFlush;
    //INFO(mLogCategory,"keep last frame:%d",mKeepFrameOnFlush);
}

void WaylandDisplay::setImmediatelyOutput(int enable)
{
    if (mVideoSurfaceWrapper) {
        wl_surface_enable_ll_mode(mVideoSurfaceWrapper, enable);
    }
    //INFO(mLogCategory,"set immediately output:%d", enable);
}

void WaylandDisplay::setFrameRate(int frameRateNum, int frameRateDenom)
{
    mFrameRateFractionNum = frameRateNum;
    mFrameRateFractionDenom = frameRateDenom;
    if (mFrameRateFractionDenom == 0) {
        mFrameRateFractionDenom = 1;
    }

    if (mFrameRateFractionNum > 0) {
        mFrameDurationUs = 1000000 * (int64_t)mFrameRateFractionDenom/(int64_t)mFrameRateFractionNum;
        mFrameRateChanged = true;
    }
    if (mVideoSurfaceWrapper && mFrameRateChanged && mAmlConfigAPIList.enableSetDisplayRate) {
        mFrameRateChanged = false;
        INFO(mLogCategory,"set frame rate %d/%d to weston", mFrameRateFractionNum, mFrameRateFractionDenom);
        wl_surface_set_display_rate(mVideoSurfaceWrapper, mFrameRateFractionNum, mFrameRateFractionDenom);
        //get dpss latency from weston
        if (mAmlConfigAPIList.enableDpss) {
            int fr = mFrameRateFractionNum * 1000/mFrameRateFractionDenom;
            if (fr <= 0) {
                fr = 60000;
            }
            TRACE(mLogCategory,"get dpss latency from weston");
            aml_config_get_dpss_latency(mAmlConfig, mCompositor, fr, mSelectOutputIndex);
        }
    }
    INFO(mLogCategory,"num:%d,denom:%d,fps:%d/100,frame dur:%lld us",
        mFrameRateFractionNum, mFrameRateFractionDenom,mFrameRateFractionNum*100/mFrameRateFractionDenom,mFrameDurationUs);
}

void WaylandDisplay::setVideoPlaneZorder(int zorder)
{
    mVideoPlaneZorder = zorder;
    mVideoPlaneZorderChanged = true;
    if (mVideoSurfaceWrapper) {
        mVideoPlaneZorderChanged = false;
        //only set zorder to area surface when doing osd displayed
        if (mVideoOnOSD) {
            wl_surface_set_zorder(mAreaSurfaceWrapper, mVideoPlaneZorder);
        }
        wl_surface_set_zorder(mVideoSurfaceWrapper, mVideoPlaneZorder);
    }
}

void WaylandDisplay::pause()
{
    mPaused = true;
    if (!mVideoIsUnderflow) {
        mLastDisplayFramePts = -1;
        mLastDisplayFrameTimeUs = -1;
    }
}
void WaylandDisplay::resume()
{
    mPaused = false;
    if (!mVideoIsUnderflow) {
        mLastDisplayFramePts = -1;
        mLastDisplayFrameTimeUs = -1;
    }
    mVideoIsUnderflow = false;
}
void WaylandDisplay::underflow()
{
    mVideoIsUnderflow = true;
}

void WaylandDisplay::setHideVideo(int hide)
{
    mHideVideo = hide;
    if (mVideoSurfaceWrapper) {
        int mute = hide > 0 ? 1: 0;
        mHideVideoChanged = false;
        INFO(mLogCategory,"mute:%d",hide);
        wl_surface_set_video_plane_mute(mVideoSurfaceWrapper, mute);
    } else {
        INFO(mLogCategory,"pending mute:%d",hide);
        mHideVideoChanged = true;
    }
}

int WaylandDisplay::unexpectReleaseFrame(RenderBuffer *buffer)
{
    WaylandBuffer *waylandBuf = NULL;

    if (buffer->flag & BUFFER_FLAG_DMA_BUFFER) {
        waylandBuf = findWaylandBuffer(buffer);
        if (waylandBuf && waylandBuf->getBufferState() == BUFFER_PREPARED) {
            DEBUG(mLogCategory," unexpected release pts:%lld us,cookie:%d",buffer->pts/1000,waylandBuf->getCookieId());
            waylandBuf->forceBufferStateIdle();
        }
    }
    return NO_ERROR;
}

void WaylandDisplay::setVideoOnOSD(int videoOnOSD)
{
    mVideoOnOSD = videoOnOSD > 0? true: false;
    INFO(mLogCategory,"video on osd:%d",mVideoOnOSD);
}

/*
 * if v2d or dpss does 90/270 degree ratotion, we should change
 * window position mapping 90/270 degree ratotion,this feature
 * is available after 6.12 kernel version.
 */
bool WaylandDisplay::checkHWRotationAvailable()
{
    bool ret = false;
    struct utsname info = {0};
    int major = 0, minor = 0;

    if (uname(&info) || sscanf(info.release, "%d.%d", &major, &minor) <= 0)
    {
        WARNING(mLogCategory,"get linux version failed");
    }

    if (major >=6 && minor >= 12) {
        ret = true;
    }
    INFO(mLogCategory,"linux major version %d.%d,HWRotation:%d", major,minor,ret);
    return ret;
}

int WaylandDisplay::getHWCLatency()
{
    return mHWCLatency;
}
int WaylandDisplay::getDisplayVsyncAndPeriod(uint64_t *vsyncTimestamp, uint64_t *vsyncPeriod)
{
    if (vsyncTimestamp && vsyncPeriod) {
        *vsyncTimestamp = mVsyncTimeUs;
        *vsyncPeriod = mVsyncPeriodUs;
        return NO_ERROR;
    }
    return ERROR_PARAM_NULL;
}