1 /*===================== begin_copyright_notice ==================================
2 
3 # Copyright (c) 2020-2021, Intel Corporation
4 
5 # Permission is hereby granted, free of charge, to any person obtaining a
6 # copy of this software and associated documentation files (the "Software"),
7 # to deal in the Software without restriction, including without limitation
8 # the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 # and/or sell copies of the Software, and to permit persons to whom the
10 # Software is furnished to do so, subject to the following conditions:
11 
12 # The above copyright notice and this permission notice shall be included
13 # in all copies or substantial portions of the Software.
14 
15 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
16 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 # OTHER DEALINGS IN THE SOFTWARE.
22 
23 ======================= end_copyright_notice ==================================*/
24 //!
25 //! \file     codechal_kernel_olp_mdf_xe_xpm.cpp
26 //! \brief    Implements the MDF OLP kernel for Xe_XPM VC1.
27 //! \details  Implements the MDF OLP kernel for Xe_XPM VC1.
28 //!
29 #include "codechal_kernel_olp_mdf_xe_xpm.h"
30 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
31 #include "Xe_XPM_VC1_OLP.h"
32 #endif
33 
Init(PMOS_INTERFACE osInterface)34 MOS_STATUS CodechalKernelOlpMdf::Init(PMOS_INTERFACE osInterface)
35 {
36     CODECHAL_DECODE_FUNCTION_ENTER;
37     CODECHAL_DECODE_CHK_NULL_RETURN(osInterface);
38     m_osInterface = osInterface;
39     if (m_cmDevice)
40     {
41         return MOS_STATUS_SUCCESS;
42     }
43 
44     osInterface->pfnNotifyStreamIndexSharing(osInterface);
45 
46     uint32_t devCreateOption = CM_DEVICE_CREATE_OPTION_SCRATCH_SPACE_DISABLE;
47     CODECHAL_DECODE_CHK_STATUS_RETURN(osInterface->pfnCreateCmDevice(
48         osInterface->pOsContext,
49         m_cmDevice,
50         devCreateOption,
51         CM_DEVICE_CREATE_PRIORITY_DEFAULT));
52 
53     CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmDevice->CreateQueue(m_cmQueue));
54 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
55     CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmDevice->LoadProgram(
56         (void *)XE_HP_VC1_OLP,
57         XE_HP_VC1_OLP_SIZE,
58         m_cmProgram,
59         "-nojitter"));
60 #endif
61     for (int i = 0; i < 2; i++)
62     {
63         CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmDevice->CreateKernel(
64             m_cmProgram,
65             "VC1_OLP_NV12",
66             m_cmKernels[i]));
67     }
68     CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmDevice->CreateTask(m_cmTask));
69 
70     return MOS_STATUS_SUCCESS;
71 }
72 
SetupSurfaces(PMOS_SURFACE src,uint16_t * srcMemory_object_control,PMOS_SURFACE dst,uint16_t * dstMemory_object_control)73 MOS_STATUS CodechalKernelOlpMdf::SetupSurfaces(PMOS_SURFACE src, uint16_t *srcMemory_object_control, PMOS_SURFACE dst, uint16_t *dstMemory_object_control)
74 {
75     CODECHAL_DECODE_FUNCTION_ENTER;
76 
77     CODECHAL_DECODE_CHK_NULL_RETURN(src);
78     CODECHAL_DECODE_CHK_NULL_RETURN(dst);
79 
80     CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmDevice->UpdateSurface2D(&src->OsResource, m_cmSurfSrc));
81     if (!m_srcYIndex)
82     {
83         CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmDevice->CreateSurface2DAlias(m_cmSurfSrc, m_srcYIndex));
84     }
85     if (!m_srcUVIndex)
86     {
87         CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmDevice->CreateSurface2DAlias(m_cmSurfSrc, m_srcUVIndex));
88     }
89 
90     CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmDevice->UpdateSurface2D(&dst->OsResource, m_cmSurfDst));
91     if (!m_dstYIndex)
92     {
93         CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmDevice->CreateSurface2DAlias(m_cmSurfDst, m_dstYIndex));
94     }
95     if (!m_dstUVIndex)
96     {
97         CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmDevice->CreateSurface2DAlias(m_cmSurfDst, m_dstUVIndex));
98     }
99 
100     CM_SURFACE2D_STATE_PARAM srcSurfParams = {};
101     CM_SURFACE2D_STATE_PARAM dstSurfParams  = {};
102     srcSurfParams.format                                      = CM_SURFACE_FORMAT_R8_UNORM;
103     srcSurfParams.memory_object_control                       = *srcMemory_object_control;
104     dstSurfParams.format                                      = CM_SURFACE_FORMAT_R8_UNORM;
105     dstSurfParams.memory_object_control                       = *dstMemory_object_control;
106     CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmSurfSrc->SetSurfaceStateParam(m_srcYIndex, &srcSurfParams));
107     CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmSurfDst->SetSurfaceStateParam(m_dstYIndex, &dstSurfParams));
108 
109     srcSurfParams.format = CM_SURFACE_FORMAT_R8G8_UNORM;
110     srcSurfParams.width  = src->dwWidth / 2;
111     srcSurfParams.height = src->dwHeight / 2;
112     dstSurfParams.format = CM_SURFACE_FORMAT_R8G8_UNORM;
113     dstSurfParams.width  = src->dwWidth / 2;
114     dstSurfParams.height = src->dwHeight / 2;
115     CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmSurfSrc->SetSurfaceStateParam(m_srcUVIndex, &srcSurfParams));
116     CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmSurfDst->SetSurfaceStateParam(m_dstUVIndex, &dstSurfParams));
117 
118     return MOS_STATUS_SUCCESS;
119 }
120 
SetKernelArgs(uint16_t flags,bool uv)121 MOS_STATUS CodechalKernelOlpMdf::SetKernelArgs(uint16_t flags, bool uv)
122 {
123     CODECHAL_DECODE_FUNCTION_ENTER;
124     uint32_t rsvd        = 0;
125     uint16_t cmpFlags    = uv ? 16 : 0;
126     uint16_t blockWidth  = 16;
127     uint16_t blockHeight = 16;
128 
129     CmKernel *cmKernel = m_cmKernels[uv ? 1 : 0];
130     CODECHAL_DECODE_CHK_STATUS_RETURN(cmKernel->SetKernelArg(0, sizeof(uint32_t), &rsvd));
131     CODECHAL_DECODE_CHK_STATUS_RETURN(cmKernel->SetKernelArg(1, sizeof(uint16_t), &blockWidth));
132     CODECHAL_DECODE_CHK_STATUS_RETURN(cmKernel->SetKernelArg(2, sizeof(uint16_t), &blockHeight));
133     CODECHAL_DECODE_CHK_STATUS_RETURN(cmKernel->SetKernelArg(3, sizeof(uint16_t), &flags));
134     CODECHAL_DECODE_CHK_STATUS_RETURN(cmKernel->SetKernelArg(4, sizeof(uint16_t), &cmpFlags));
135     CODECHAL_DECODE_CHK_STATUS_RETURN(cmKernel->SetKernelArg(5, sizeof(uint16_t), &rsvd));
136     if (uv)
137     {
138         CODECHAL_DECODE_CHK_STATUS_RETURN(cmKernel->SetKernelArg(6, sizeof(SurfaceIndex), m_srcUVIndex));
139         CODECHAL_DECODE_CHK_STATUS_RETURN(cmKernel->SetKernelArg(7, sizeof(SurfaceIndex), m_dstUVIndex));
140     }
141     else
142     {
143         CODECHAL_DECODE_CHK_STATUS_RETURN(cmKernel->SetKernelArg(6, sizeof(SurfaceIndex), m_srcYIndex));
144         CODECHAL_DECODE_CHK_STATUS_RETURN(cmKernel->SetKernelArg(7, sizeof(SurfaceIndex), m_dstYIndex));
145     }
146     return MOS_STATUS_SUCCESS;
147 }
148 
Execute(PMOS_SURFACE src,uint16_t * srcMemory_object_control,PMOS_SURFACE dst,uint16_t * dstMemory_object_control,uint16_t flags)149 MOS_STATUS CodechalKernelOlpMdf::Execute(PMOS_SURFACE src, uint16_t *srcMemory_object_control, PMOS_SURFACE dst, uint16_t *dstMemory_object_control, uint16_t flags)
150 {
151     CODECHAL_DECODE_FUNCTION_ENTER;
152 
153     CmEvent *event = CM_NO_EVENT;
154 
155     uint32_t threadWidth  = MOS_ALIGN_CEIL(src->dwWidth, 16) / 16;
156     uint32_t threadHeight = MOS_ALIGN_CEIL(src->dwHeight, 16) / 16;
157 
158     CODECHAL_DECODE_CHK_STATUS_RETURN(SetupSurfaces(src, srcMemory_object_control, dst, dstMemory_object_control));
159 
160     CODECHAL_DECODE_CHK_STATUS_RETURN(SetKernelArgs(flags, false));
161     CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmDevice->CreateThreadGroupSpace(1, 1, threadWidth, threadHeight, m_threadGroupSpaces[0]));
162     CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmKernels[0]->AssociateThreadGroupSpace(m_threadGroupSpaces[0]));
163     CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmTask->AddKernel(m_cmKernels[0]));
164 
165     auto delete_event = [&]()
166     {
167         MOS_Delete(event);
168     };
169 
170     if (!m_SingleTaskPhase)
171     {
172         CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_cmQueue->EnqueueWithGroup(m_cmTask, event), delete_event);
173         CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_cmTask->Reset(), delete_event);
174     }
175 
176     threadWidth  = MOS_ALIGN_CEIL(src->dwWidth, 16) / 16;
177     threadHeight = MOS_ALIGN_CEIL(src->dwHeight / 2, 16) / 16;
178 
179     CODECHAL_DECODE_CHK_STATUS_RETURN(SetKernelArgs(flags, true));
180     CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmDevice->CreateThreadGroupSpace(1, 1, threadWidth, threadHeight, m_threadGroupSpaces[1]));
181     CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmKernels[1]->AssociateThreadGroupSpace(m_threadGroupSpaces[1]));
182     CODECHAL_DECODE_CHK_STATUS_RETURN(m_cmTask->AddKernel(m_cmKernels[1]));
183     CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_cmQueue->EnqueueWithGroup(m_cmTask, event), delete_event);
184     CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_cmTask->Reset(), delete_event);
185 
186 
187     return MOS_STATUS_SUCCESS;
188 }
189 
UnInit()190 MOS_STATUS CodechalKernelOlpMdf::UnInit()
191 {
192     CODECHAL_DECODE_FUNCTION_ENTER;
193 
194     if (m_cmSurfSrc)
195     {
196         m_cmDevice->DestroySurface(m_cmSurfSrc);
197     }
198     if (m_cmSurfDst)
199     {
200         m_cmDevice->DestroySurface(m_cmSurfDst);
201     }
202 
203     for (int i = 0; i < 2; i++)
204     {
205         if (m_threadGroupSpaces[i])
206         {
207             m_cmDevice->DestroyThreadGroupSpace(m_threadGroupSpaces[i]);
208             m_threadGroupSpaces[i] = nullptr;
209         }
210         if (m_cmKernels[i])
211         {
212             m_cmDevice->DestroyKernel(m_cmKernels[i]);
213             m_cmKernels[i] = nullptr;
214         }
215     }
216     if (m_cmTask)
217     {
218         m_cmDevice->DestroyTask(m_cmTask);
219         m_cmTask = nullptr;
220     }
221     if (m_cmProgram)
222     {
223         m_cmDevice->DestroyProgram(m_cmProgram);
224         m_cmProgram = nullptr;
225     }
226     if (m_osInterface != nullptr)
227     {
228         m_osInterface->pfnDestroyCmDevice(m_cmDevice);
229     }
230 
231     return MOS_STATUS_SUCCESS;
232 }
233