1 /*
2 * Copyright (C) 2016 Intel Corporation. All Rights Reserved.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sub license, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial portions
14 * of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
19 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
20 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25 #include "test_va_api_fixture.h"
26
27 namespace VAAPI
28 {
29
30 // Testing VABufferType in groups that will be associated with VAProfile and
31 // VAEntrypoint. vaCreateBuffer doesn't require these itself but its input
32 // parameter do care about them.
33
34 typedef ::testing::WithParamInterface<std::tuple<VAProfile, VAEntrypoint,
35 VABufferType, size_t>> CreateBufferParamInterface;
36
37 class VAAPICreateBuffer
38 : public VAAPIFixture
39 , public CreateBufferParamInterface
40 {
41 public:
VAAPICreateBuffer()42 VAAPICreateBuffer()
43 : profile(::testing::get<0>(GetParam()))
44 , entrypoint(::testing::get<1>(GetParam()))
45 , bufferType(::testing::get<2>(GetParam()))
46 , bufferSize(::testing::get<3>(GetParam()))
47 { }
48
49 protected:
50 const VAProfile& profile;
51 const VAEntrypoint& entrypoint;
52 const VABufferType& bufferType;
53 const size_t bufferSize;
54
SetUp()55 virtual void SetUp()
56 {
57 VAAPIFixture::SetUp();
58 doInitialize();
59 ASSERT_FALSE(HasFailure());
60 }
61
TearDown()62 virtual void TearDown()
63 {
64 doTerminate();
65 VAAPIFixture::TearDown();
66 }
67 };
68
69 typedef std::tuple<Profiles, size_t> BufferSpec;
70 typedef std::vector<BufferSpec> BufferSpecs;
71 typedef std::map<VABufferType, BufferSpecs> BufferSpecsMap;
72
73 using std::make_tuple;
74
75 static const BufferSpecsMap decodeBufferSpecs = {
76 {
77 VAPictureParameterBufferType, {
78 make_tuple(g_vaMPEG2Profiles, sizeof(VAPictureParameterBufferMPEG2)),
79 make_tuple(g_vaMPEG4Profiles, sizeof(VAPictureParameterBufferMPEG4)),
80 make_tuple(g_vaH264Profiles, sizeof(VAPictureParameterBufferH264)),
81 make_tuple(g_vaVC1Profiles, sizeof(VAPictureParameterBufferVC1)),
82 make_tuple(g_vaJPEGProfiles,
83 sizeof(VAPictureParameterBufferJPEGBaseline)),
84 make_tuple(g_vaVP8Profiles, sizeof(VAPictureParameterBufferVP8)),
85 make_tuple(g_vaHEVCProfiles, sizeof(VAPictureParameterBufferHEVC)),
86 make_tuple(g_vaVP9Profiles, sizeof(VADecPictureParameterBufferVP9)),
87 }
88 },
89 {
90 VAIQMatrixBufferType, {
91 make_tuple(g_vaMPEG2Profiles, sizeof(VAIQMatrixBufferMPEG2)),
92 make_tuple(g_vaMPEG4Profiles, sizeof(VAIQMatrixBufferMPEG4)),
93 make_tuple(g_vaH264Profiles, sizeof(VAIQMatrixBufferH264)),
94 make_tuple(g_vaJPEGProfiles, sizeof(VAIQMatrixBufferJPEGBaseline)),
95 make_tuple(g_vaVP8Profiles, sizeof(VAIQMatrixBufferVP8)),
96 make_tuple(g_vaHEVCProfiles, sizeof(VAIQMatrixBufferHEVC)),
97 }
98 },
99 {
100 VASliceParameterBufferType, {
101 make_tuple(g_vaMPEG2Profiles, sizeof(VASliceParameterBufferMPEG2)),
102 make_tuple(g_vaMPEG4Profiles, sizeof(VASliceParameterBufferMPEG4)),
103 make_tuple(g_vaH264Profiles, sizeof(VASliceParameterBufferH264)),
104 make_tuple(g_vaVC1Profiles, sizeof(VASliceParameterBufferVC1)),
105 make_tuple(g_vaJPEGProfiles,
106 sizeof(VASliceParameterBufferJPEGBaseline)),
107 make_tuple(g_vaVP8Profiles, sizeof(VASliceParameterBufferVP8)),
108 make_tuple(g_vaHEVCProfiles, sizeof(VASliceParameterBufferHEVC)),
109 make_tuple(g_vaVP9Profiles, sizeof(VASliceParameterBufferVP9)),
110 }
111 },
112 {
113 VAMacroblockParameterBufferType, {
114 make_tuple(g_vaMPEG2Profiles, sizeof(VAMacroblockParameterBufferMPEG2)),
115 }
116 },
117 {
118 VAQMatrixBufferType, {
119 make_tuple(g_vaJPEGProfiles, sizeof(VAQMatrixBufferJPEG)),
120 make_tuple(g_vaVP8Profiles, sizeof(VAQMatrixBufferVP8)),
121 make_tuple(g_vaHEVCProfiles, sizeof(VAQMatrixBufferHEVC)),
122 }
123 },
124 {
125 VAHuffmanTableBufferType, {
126 make_tuple(g_vaJPEGProfiles, sizeof(VAHuffmanTableBufferJPEGBaseline)),
127 }
128 },
129 {
130 VAProbabilityBufferType, {
131 make_tuple(g_vaVP8Profiles, sizeof(VAProbabilityDataBufferVP8)),
132 }
133 },
134 };
135
136 static const BufferSpecsMap encodeBufferSpecs = {
137 {
138 VAEncSequenceParameterBufferType, {
139 make_tuple(g_vaMPEG2Profiles,
140 sizeof(VAEncSequenceParameterBufferMPEG2)),
141 make_tuple(g_vaMPEG4Profiles,
142 sizeof(VAEncSequenceParameterBufferMPEG4)),
143 make_tuple(g_vaH263Profiles, sizeof(VAEncSequenceParameterBufferH263)),
144 make_tuple(g_vaH264Profiles, sizeof(VAEncSequenceParameterBufferH264)),
145 make_tuple(g_vaVP8Profiles, sizeof(VAEncSequenceParameterBufferVP8)),
146 make_tuple(g_vaHEVCProfiles, sizeof(VAEncSequenceParameterBufferHEVC)),
147 make_tuple(g_vaVP9Profiles, sizeof(VAEncSequenceParameterBufferVP9)),
148 make_tuple(g_vaAV1Profiles, sizeof(VAEncSequenceParameterBufferAV1)),
149 }
150 },
151 {
152 VAEncPictureParameterBufferType, {
153 make_tuple(g_vaMPEG2Profiles, sizeof(VAEncPictureParameterBufferMPEG2)),
154 make_tuple(g_vaMPEG4Profiles, sizeof(VAEncPictureParameterBufferMPEG4)),
155 make_tuple(g_vaH263Profiles, sizeof(VAEncPictureParameterBufferH263)),
156 make_tuple(g_vaH264Profiles, sizeof(VAEncPictureParameterBufferH264)),
157 make_tuple(g_vaJPEGProfiles, sizeof(VAEncPictureParameterBufferJPEG)),
158 make_tuple(g_vaVP8Profiles, sizeof(VAEncPictureParameterBufferVP8)),
159 make_tuple(g_vaHEVCProfiles, sizeof(VAEncPictureParameterBufferHEVC)),
160 make_tuple(g_vaVP9Profiles, sizeof(VAEncPictureParameterBufferVP9)),
161 make_tuple(g_vaAV1Profiles, sizeof(VAEncPictureParameterBufferAV1)),
162 }
163 },
164 {
165 VAEncSliceParameterBufferType, {
166 make_tuple(g_vaMPEG2Profiles, sizeof(VAEncSliceParameterBufferMPEG2)),
167 make_tuple(g_vaH264Profiles, sizeof(VAEncSliceParameterBufferH264)),
168 make_tuple(g_vaJPEGProfiles, sizeof(VAEncSliceParameterBufferJPEG)),
169 make_tuple(g_vaHEVCProfiles, sizeof(VAEncSliceParameterBufferHEVC)),
170 make_tuple(g_vaAV1Profiles, sizeof(VAEncPictureParameterBufferAV1)),
171 }
172 },
173 {
174 VAEncPackedHeaderParameterBufferType, {
175 make_tuple(g_vaProfiles, sizeof(VAEncPackedHeaderParameterBuffer)),
176 make_tuple(g_vaAV1Profiles, sizeof(VAEncPictureParameterBufferAV1)),
177 }
178 },
179 {
180 VAEncMiscParameterBufferType, {
181 make_tuple(g_vaProfiles, sizeof(VAEncMiscParameterBuffer)),
182 make_tuple(g_vaAV1Profiles, sizeof(VAEncPictureParameterBufferAV1)),
183 }
184 },
185 };
186
187 static const BufferSpecsMap vppBufferSpecs = {
188 {
189 VAProcPipelineParameterBufferType, {
190 make_tuple(g_vaNoneProfiles, sizeof(VAProcPipelineParameterBuffer)),
191 }
192 },
193 {
194 VAProcFilterParameterBufferType, {
195 make_tuple(g_vaNoneProfiles, sizeof(VAProcFilterParameterBuffer)),
196 make_tuple(g_vaNoneProfiles,
197 sizeof(VAProcFilterParameterBufferDeinterlacing)),
198 make_tuple(g_vaNoneProfiles,
199 sizeof(VAProcFilterParameterBufferColorBalance)),
200 make_tuple(g_vaNoneProfiles,
201 sizeof(VAProcFilterParameterBufferTotalColorCorrection)),
202 }
203 },
204 };
205
TEST_P(VAAPICreateBuffer,CreateBufferWithOutData)206 TEST_P(VAAPICreateBuffer, CreateBufferWithOutData)
207 {
208 // vaCreateBuffer uses a VAContextID as an input. This VAContextID requires
209 // a VAConfigID to be created. VAConfigID requires VAProfile and
210 // VAEntrypoint to be given. As such, to test vaCreateBuffer these are
211 // the minimum requirements. There's no need to create surfaces or attach
212 // them to a VAConfigID.
213
214 if (!isSupported(profile, entrypoint)) {
215 skipTest(profile, entrypoint);
216 return;
217 }
218
219 // profile and entrypoint are supported
220 createConfig(profile, entrypoint);
221
222 // vaCreateContext input requires resolution, since this test
223 // doesn't create surfaces, passing min resolution should provide
224 // the desired result.
225 Resolution minRes, maxRes;
226 getMinMaxSurfaceResolution(minRes, maxRes);
227 doCreateContext(minRes);
228
229 createBuffer(bufferType, bufferSize);
230 destroyBuffer();
231
232 doDestroyContext();
233 destroyConfig();
234 }
235
generateInput()236 std::vector<CreateBufferParamInterface::ParamType> generateInput()
237 {
238 std::vector<CreateBufferParamInterface::ParamType> inputs;
239
240 const auto addBufferSpecs = [&](
241 const BufferSpecsMap & bsm, const Entrypoints & entrypoints) {
242 for (const auto& specs : bsm) {
243 const auto& bufferType = std::get<0>(specs);
244 for (const auto& spec : std::get<1>(specs)) {
245 const auto& bufferSize = std::get<1>(spec);
246 for (const auto& profile : std::get<0>(spec)) {
247 for (const auto& entrypoint : entrypoints) {
248 inputs.push_back(
249 make_tuple(
250 profile, entrypoint, bufferType, bufferSize));
251 }
252 }
253 }
254 }
255 };
256
257 addBufferSpecs(decodeBufferSpecs, {VAEntrypointVLD,});
258 addBufferSpecs(encodeBufferSpecs, {VAEntrypointEncSlice,
259 VAEntrypointEncSliceLP, VAEntrypointEncPicture,
260 });
261 addBufferSpecs(vppBufferSpecs, {VAEntrypointVideoProc,});
262
263 return inputs;
264 }
265
266 INSTANTIATE_TEST_SUITE_P(
267 CreateBuffer, VAAPICreateBuffer,
268 ::testing::ValuesIn(generateInput()));
269
270 } // namespace VAAPI
271