|
1 |
|
2 // Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 // All rights reserved. |
|
4 // This component and the accompanying materials are made available |
|
5 // under the terms of "Eclipse Public License v1.0" |
|
6 // which accompanies this distribution, and is available |
|
7 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 // |
|
9 // Initial Contributors: |
|
10 // Nokia Corporation - initial contribution. |
|
11 // |
|
12 // Contributors: |
|
13 // |
|
14 // Description: |
|
15 // TestDevVideoPlay.cpp |
|
16 // |
|
17 // |
|
18 |
|
19 #include "TestDevVideoPlay.h" |
|
20 #include "TestDevVideoPlayTestData.h" |
|
21 #include "TestDevVideoPlugins/decoder.h" |
|
22 #include "TestDevVideoPlugins/postproc.h" |
|
23 #include <e32math.h> |
|
24 |
|
25 void CTestDevVideoPlayResume::MdvpoInitComplete(TInt aError) |
|
26 { |
|
27 INFO_PRINTF2(_L("CTestDevVideoPlayResume::MdvpoInitComplete(): Error = %d"), aError); |
|
28 |
|
29 iError = aError; |
|
30 } |
|
31 |
|
32 CTestDevVideoPlayResume::CTestDevVideoPlayResume(const TDesC& aTestName, TTestType aTestType) |
|
33 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
34 { |
|
35 } |
|
36 |
|
37 CTestDevVideoPlayResume* CTestDevVideoPlayResume::NewL(const TDesC& aTestName, TTestType aTestType) |
|
38 { |
|
39 CTestDevVideoPlayResume* self = new(ELeave) CTestDevVideoPlayResume(aTestName, aTestType); |
|
40 return self; |
|
41 } |
|
42 |
|
43 TVerdict CTestDevVideoPlayResume::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
44 { |
|
45 TVerdict ret = EPass; |
|
46 // TInt expErr = KErrNone; |
|
47 TBool selDec = ETrue; |
|
48 TBool selPost = ETrue; |
|
49 |
|
50 INFO_PRINTF1(_L("CMMFDevVideoPlay: Resume")); |
|
51 |
|
52 // expected results |
|
53 switch(iTestType) |
|
54 { |
|
55 case ETestValid: |
|
56 // expErr = KErrNone; // EABI warning removal |
|
57 break; |
|
58 case ETestDecoderOnly: |
|
59 selPost = EFalse; |
|
60 break; |
|
61 case ETestPostProcOnly: |
|
62 selDec = EFalse; |
|
63 break; |
|
64 default: |
|
65 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
66 return EInconclusive; |
|
67 } |
|
68 |
|
69 TInt err = KErrNone; |
|
70 |
|
71 // THwDeviceId hwDecoder = 0; |
|
72 // THwDeviceId hwPostProc = 0; |
|
73 |
|
74 // select decoder |
|
75 if (selDec) |
|
76 { |
|
77 // TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
78 TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal |
|
79 if (err != KErrNone) |
|
80 { |
|
81 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
82 return EInconclusive; |
|
83 } |
|
84 } |
|
85 |
|
86 // select post-processor |
|
87 if (selPost) |
|
88 { |
|
89 // TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
90 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
91 if (err != KErrNone) |
|
92 { |
|
93 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
94 return EInconclusive; |
|
95 } |
|
96 } |
|
97 |
|
98 // initialize CDevVideoPlay and wait for response |
|
99 // iError is set by the MdvpoInitComplete callback |
|
100 aDevVideoPlay.Initialize(); |
|
101 |
|
102 if (iError != KErrNone) |
|
103 { |
|
104 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
105 return EInconclusive; |
|
106 } |
|
107 |
|
108 // check not already playing |
|
109 TBool playing = aDevVideoPlay.IsPlaying(); |
|
110 if (playing) |
|
111 { |
|
112 ERR_PRINTF1(_L("Error - DevVideoPlay already playing!")); |
|
113 return EInconclusive; |
|
114 } |
|
115 |
|
116 // call resume on DevVideoPlay then check IsPlaying() |
|
117 aDevVideoPlay.Resume(); |
|
118 playing = aDevVideoPlay.IsPlaying(); |
|
119 |
|
120 if (!playing) |
|
121 { |
|
122 ERR_PRINTF1(_L("IsPlaying() returned EFalse - expected ETrue")); |
|
123 ret = EFail; |
|
124 } |
|
125 else |
|
126 INFO_PRINTF1(_L("Resume() called successfully")); |
|
127 |
|
128 return ret; |
|
129 } |
|
130 //------------------------------------------------------------------ |
|
131 |
|
132 void CTestDevVideoPlaySetPosition::MdvpoInitComplete(TInt aError) |
|
133 { |
|
134 INFO_PRINTF2(_L("CTestDevVideoPlaySetPosition::MdvpoInitComplete(): Error = %d"), aError); |
|
135 |
|
136 iError = aError; |
|
137 } |
|
138 |
|
139 CTestDevVideoPlaySetPosition::CTestDevVideoPlaySetPosition(const TDesC& aTestName, TTestType aTestType) |
|
140 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
141 { |
|
142 } |
|
143 |
|
144 CTestDevVideoPlaySetPosition* CTestDevVideoPlaySetPosition::NewL(const TDesC& aTestName, TTestType aTestType) |
|
145 { |
|
146 CTestDevVideoPlaySetPosition* self = new(ELeave) CTestDevVideoPlaySetPosition(aTestName, aTestType); |
|
147 return self; |
|
148 } |
|
149 |
|
150 TVerdict CTestDevVideoPlaySetPosition::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
151 { |
|
152 TVerdict ret = EPass; |
|
153 TInt expErr = KErrNone; |
|
154 TBool selDec = ETrue; |
|
155 TBool selPost = ETrue; |
|
156 TInt testPos = KTestPosition; |
|
157 |
|
158 INFO_PRINTF1(_L("CMMFDevVideoPlay: SetPosition")); |
|
159 |
|
160 // expected results |
|
161 switch(iTestType) |
|
162 { |
|
163 case ETestValid: |
|
164 expErr = KErrNone; |
|
165 break; |
|
166 case ETestBothFatal: |
|
167 expErr = KErrDied; |
|
168 testPos = KTestPositionFatal; |
|
169 break; |
|
170 case ETestDecoderFatal: |
|
171 expErr = KErrDied; |
|
172 testPos = KTestPositionFatal; |
|
173 // fall through to set post proc to false; |
|
174 case ETestDecoderOnly: |
|
175 selPost = EFalse; |
|
176 break; |
|
177 case ETestPostProcFatal: |
|
178 expErr = KErrDied; |
|
179 testPos = KTestPositionFatal; |
|
180 // fall through to set decoder to false; |
|
181 case ETestPostProcOnly: |
|
182 selDec = EFalse; |
|
183 break; |
|
184 default: |
|
185 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
186 return EInconclusive; |
|
187 } |
|
188 |
|
189 TInt err = KErrNone; |
|
190 |
|
191 // THwDeviceId hwDecoder = 0; |
|
192 // THwDeviceId hwPostProc = 0; |
|
193 |
|
194 // select decoder |
|
195 if (selDec) |
|
196 { |
|
197 // TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
198 TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal |
|
199 if (err != KErrNone) |
|
200 { |
|
201 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
202 return EInconclusive; |
|
203 } |
|
204 } |
|
205 |
|
206 // select post-processor |
|
207 if (selPost) |
|
208 { |
|
209 // TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
210 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
211 if (err != KErrNone) |
|
212 { |
|
213 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
214 return EInconclusive; |
|
215 } |
|
216 } |
|
217 |
|
218 // initialize CDevVideoPlay and wait for response |
|
219 // iError is set by the MdvpoInitComplete callback |
|
220 aDevVideoPlay.Initialize(); |
|
221 |
|
222 if (iError != KErrNone) |
|
223 { |
|
224 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
225 return EInconclusive; |
|
226 } |
|
227 |
|
228 TTimeIntervalMicroSeconds pos(testPos); |
|
229 |
|
230 // call SetPosition |
|
231 aDevVideoPlay.SetPosition(pos); |
|
232 |
|
233 // if no PANIC and iError is as expected then test has passed |
|
234 // if performing a fatal test then expect iError = KErrDied |
|
235 if (iError == expErr) |
|
236 { |
|
237 ERR_PRINTF3(_L("SetPosition() got error %d; Expected %d"), iError, expErr); |
|
238 } |
|
239 else |
|
240 { |
|
241 INFO_PRINTF1(_L("SetPosition() called successfully")); |
|
242 } |
|
243 return ret; |
|
244 } |
|
245 //------------------------------------------------------------------ |
|
246 |
|
247 void CTestDevVideoPlayFreezePicture::MdvpoInitComplete(TInt aError) |
|
248 { |
|
249 INFO_PRINTF2(_L("CTestDevVideoPlayFreezePicture::MdvpoInitComplete(): Error = %d"), aError); |
|
250 |
|
251 iError = aError; |
|
252 } |
|
253 |
|
254 CTestDevVideoPlayFreezePicture::CTestDevVideoPlayFreezePicture(const TDesC& aTestName, TTestType aTestType) |
|
255 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
256 { |
|
257 } |
|
258 |
|
259 CTestDevVideoPlayFreezePicture* CTestDevVideoPlayFreezePicture::NewL(const TDesC& aTestName, TTestType aTestType) |
|
260 { |
|
261 CTestDevVideoPlayFreezePicture* self = new(ELeave) CTestDevVideoPlayFreezePicture(aTestName, aTestType); |
|
262 return self; |
|
263 } |
|
264 |
|
265 TVerdict CTestDevVideoPlayFreezePicture::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
266 { |
|
267 TVerdict ret = EPass; |
|
268 |
|
269 INFO_PRINTF1(_L("CMMFDevVideoPlay: FreezePicture")); |
|
270 |
|
271 // expected results |
|
272 if (iTestType != ETestValid) |
|
273 { |
|
274 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
275 return EInconclusive; |
|
276 } |
|
277 |
|
278 TInt err = KErrNone; |
|
279 |
|
280 // THwDeviceId hwDecoder = 0; |
|
281 // THwDeviceId hwPostProc = 0; |
|
282 |
|
283 // select decoder |
|
284 // TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
285 TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal |
|
286 if (err != KErrNone) |
|
287 { |
|
288 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
289 return EInconclusive; |
|
290 } |
|
291 |
|
292 // select post-processor |
|
293 // TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
294 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
295 if (err != KErrNone) |
|
296 { |
|
297 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
298 return EInconclusive; |
|
299 } |
|
300 |
|
301 // initialize CDevVideoPlay and wait for response |
|
302 // iError is set by the MdvpoInitComplete callback |
|
303 aDevVideoPlay.Initialize(); |
|
304 |
|
305 if (iError != KErrNone) |
|
306 { |
|
307 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
308 return EInconclusive; |
|
309 } |
|
310 |
|
311 TTimeIntervalMicroSeconds pos(KTestPosition); |
|
312 |
|
313 // call FreezePicture |
|
314 aDevVideoPlay.FreezePicture(pos); |
|
315 |
|
316 // if no PANIC then test has passed |
|
317 |
|
318 INFO_PRINTF1(_L("FreezePicture() called successfully")); |
|
319 |
|
320 return ret; |
|
321 } |
|
322 //------------------------------------------------------------------ |
|
323 |
|
324 void CTestDevVideoPlayReleaseFreeze::MdvpoInitComplete(TInt aError) |
|
325 { |
|
326 INFO_PRINTF2(_L("CTestDevVideoPlayReleaseFreeze::MdvpoInitComplete(): Error = %d"), aError); |
|
327 |
|
328 iError = aError; |
|
329 } |
|
330 |
|
331 CTestDevVideoPlayReleaseFreeze::CTestDevVideoPlayReleaseFreeze(const TDesC& aTestName, TTestType aTestType) |
|
332 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
333 { |
|
334 } |
|
335 |
|
336 CTestDevVideoPlayReleaseFreeze* CTestDevVideoPlayReleaseFreeze::NewL(const TDesC& aTestName, TTestType aTestType) |
|
337 { |
|
338 CTestDevVideoPlayReleaseFreeze* self = new(ELeave) CTestDevVideoPlayReleaseFreeze(aTestName, aTestType); |
|
339 return self; |
|
340 } |
|
341 |
|
342 TVerdict CTestDevVideoPlayReleaseFreeze::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
343 { |
|
344 TVerdict ret = EPass; |
|
345 |
|
346 INFO_PRINTF1(_L("CMMFDevVideoPlay: ReleaseFreeze")); |
|
347 |
|
348 // expected results |
|
349 if (iTestType != ETestValid) |
|
350 { |
|
351 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
352 return EInconclusive; |
|
353 } |
|
354 |
|
355 TInt err = KErrNone; |
|
356 |
|
357 // THwDeviceId hwDecoder = 0; |
|
358 // THwDeviceId hwPostProc = 0; |
|
359 |
|
360 // select decoder |
|
361 // TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
362 TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal |
|
363 if (err != KErrNone) |
|
364 { |
|
365 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
366 return EInconclusive; |
|
367 } |
|
368 |
|
369 // select post-processor |
|
370 // TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
371 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
372 if (err != KErrNone) |
|
373 { |
|
374 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
375 return EInconclusive; |
|
376 } |
|
377 |
|
378 // initialize CDevVideoPlay and wait for response |
|
379 // iError is set by the MdvpoInitComplete callback |
|
380 aDevVideoPlay.Initialize(); |
|
381 |
|
382 if (iError != KErrNone) |
|
383 { |
|
384 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
385 return EInconclusive; |
|
386 } |
|
387 |
|
388 TTimeIntervalMicroSeconds pos(KTestPosition); |
|
389 |
|
390 // call ReleaseFreeze |
|
391 aDevVideoPlay.ReleaseFreeze(pos); |
|
392 |
|
393 // if no PANIC then test has passed |
|
394 |
|
395 INFO_PRINTF1(_L("ReleaseFreeze() called successfully")); |
|
396 |
|
397 return ret; |
|
398 } |
|
399 //------------------------------------------------------------------ |
|
400 |
|
401 void CTestDevVideoPlayDecodingPosition::MdvpoInitComplete(TInt aError) |
|
402 { |
|
403 INFO_PRINTF2(_L("CTestDevVideoPlayDecodingPosition::MdvpoInitComplete(): Error = %d"), aError); |
|
404 |
|
405 iError = aError; |
|
406 } |
|
407 |
|
408 CTestDevVideoPlayDecodingPosition::CTestDevVideoPlayDecodingPosition(const TDesC& aTestName, TTestType aTestType) |
|
409 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
410 { |
|
411 } |
|
412 |
|
413 CTestDevVideoPlayDecodingPosition* CTestDevVideoPlayDecodingPosition::NewL(const TDesC& aTestName, TTestType aTestType) |
|
414 { |
|
415 CTestDevVideoPlayDecodingPosition* self = new(ELeave) CTestDevVideoPlayDecodingPosition(aTestName, aTestType); |
|
416 return self; |
|
417 } |
|
418 |
|
419 TVerdict CTestDevVideoPlayDecodingPosition::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
420 { |
|
421 TVerdict ret = EPass; |
|
422 |
|
423 INFO_PRINTF1(_L("CMMFDevVideoPlay: DecodingPosition")); |
|
424 |
|
425 // expected results |
|
426 if (iTestType != ETestValid) |
|
427 { |
|
428 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
429 return EInconclusive; |
|
430 } |
|
431 |
|
432 TInt err = KErrNone; |
|
433 |
|
434 // THwDeviceId hwDecoder = 0; |
|
435 // THwDeviceId hwPostProc = 0; |
|
436 |
|
437 // select decoder |
|
438 // TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
439 TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal |
|
440 if (err != KErrNone) |
|
441 { |
|
442 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
443 return EInconclusive; |
|
444 } |
|
445 |
|
446 // select post-processor |
|
447 // TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
448 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
449 if (err != KErrNone) |
|
450 { |
|
451 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
452 return EInconclusive; |
|
453 } |
|
454 |
|
455 // initialize CDevVideoPlay and wait for response |
|
456 // iError is set by the MdvpoInitComplete callback |
|
457 aDevVideoPlay.Initialize(); |
|
458 |
|
459 if (iError != KErrNone) |
|
460 { |
|
461 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
462 return EInconclusive; |
|
463 } |
|
464 |
|
465 // get decoding position |
|
466 TTimeIntervalMicroSeconds decPos = aDevVideoPlay.DecodingPosition(); |
|
467 |
|
468 // check against test data |
|
469 TTimeIntervalMicroSeconds testTime(KTestDecodePosition); |
|
470 if (decPos != testTime) |
|
471 { |
|
472 ERR_PRINTF3(_L("DecodingPosition() incorrect - gave %d (expected %d)"), |
|
473 I64LOW(decPos.Int64()), KTestDecodePosition); |
|
474 ret = EFail; |
|
475 } |
|
476 else |
|
477 INFO_PRINTF1(_L("DecodingPosition() called successfully")); |
|
478 |
|
479 return ret; |
|
480 } |
|
481 //------------------------------------------------------------------ |
|
482 |
|
483 void CTestDevVideoPlayPlaybackPosition::MdvpoInitComplete(TInt aError) |
|
484 { |
|
485 INFO_PRINTF2(_L("CTestDevVideoPlayPlaybackPosition::MdvpoInitComplete(): Error = %d"), aError); |
|
486 |
|
487 iError = aError; |
|
488 } |
|
489 |
|
490 CTestDevVideoPlayPlaybackPosition::CTestDevVideoPlayPlaybackPosition(const TDesC& aTestName, TTestType aTestType) |
|
491 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
492 { |
|
493 } |
|
494 |
|
495 CTestDevVideoPlayPlaybackPosition* CTestDevVideoPlayPlaybackPosition::NewL(const TDesC& aTestName, TTestType aTestType) |
|
496 { |
|
497 CTestDevVideoPlayPlaybackPosition* self = new(ELeave) CTestDevVideoPlayPlaybackPosition(aTestName, aTestType); |
|
498 return self; |
|
499 } |
|
500 |
|
501 TVerdict CTestDevVideoPlayPlaybackPosition::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
502 { |
|
503 TVerdict ret = EPass; |
|
504 |
|
505 INFO_PRINTF1(_L("CMMFDevVideoPlay: PlaybackPosition")); |
|
506 |
|
507 // expected results |
|
508 if (iTestType != ETestValid) |
|
509 { |
|
510 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
511 return EInconclusive; |
|
512 } |
|
513 |
|
514 TInt err = KErrNone; |
|
515 |
|
516 // THwDeviceId hwDecoder = 0; |
|
517 // THwDeviceId hwPostProc = 0; |
|
518 |
|
519 // select decoder |
|
520 // TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
521 TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal |
|
522 if (err != KErrNone) |
|
523 { |
|
524 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
525 return EInconclusive; |
|
526 } |
|
527 |
|
528 // select post-processor |
|
529 // TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
530 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
531 if (err != KErrNone) |
|
532 { |
|
533 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
534 return EInconclusive; |
|
535 } |
|
536 |
|
537 // initialize CDevVideoPlay and wait for response |
|
538 // iError is set by the MdvpoInitComplete callback |
|
539 aDevVideoPlay.Initialize(); |
|
540 |
|
541 if (iError != KErrNone) |
|
542 { |
|
543 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
544 return EInconclusive; |
|
545 } |
|
546 |
|
547 // get playback position |
|
548 TTimeIntervalMicroSeconds playPos = aDevVideoPlay.PlaybackPosition(); |
|
549 |
|
550 // check against test data |
|
551 TTimeIntervalMicroSeconds testTime(KTestPlayPosition); |
|
552 if (playPos != testTime) |
|
553 { |
|
554 ERR_PRINTF3(_L("PlaybackPosition() incorrect - gave %d (expected %d)"), |
|
555 I64LOW(playPos.Int64()), KTestPlayPosition); |
|
556 ret = EFail; |
|
557 } |
|
558 else |
|
559 INFO_PRINTF1(_L("PlaybackPosition() called successfully")); |
|
560 |
|
561 return ret; |
|
562 } |
|
563 //------------------------------------------------------------------ |
|
564 |
|
565 void CTestDevVideoPlayPreDecoderBufferBytes::MdvpoInitComplete(TInt aError) |
|
566 { |
|
567 INFO_PRINTF2(_L("CTestDevVideoPlayPreDecoderBufferBytes::MdvpoInitComplete(): Error = %d"), aError); |
|
568 |
|
569 iError = aError; |
|
570 } |
|
571 |
|
572 CTestDevVideoPlayPreDecoderBufferBytes::CTestDevVideoPlayPreDecoderBufferBytes(const TDesC& aTestName, TTestType aTestType) |
|
573 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
574 { |
|
575 } |
|
576 |
|
577 CTestDevVideoPlayPreDecoderBufferBytes* CTestDevVideoPlayPreDecoderBufferBytes::NewL(const TDesC& aTestName, TTestType aTestType) |
|
578 { |
|
579 CTestDevVideoPlayPreDecoderBufferBytes* self = new(ELeave) CTestDevVideoPlayPreDecoderBufferBytes(aTestName, aTestType); |
|
580 return self; |
|
581 } |
|
582 |
|
583 TVerdict CTestDevVideoPlayPreDecoderBufferBytes::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
584 { |
|
585 TVerdict ret = EPass; |
|
586 |
|
587 INFO_PRINTF1(_L("CMMFDevVideoPlay: PreDecoderBufferBytes")); |
|
588 |
|
589 // expected results |
|
590 if (iTestType != ETestValid) |
|
591 { |
|
592 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
593 return EInconclusive; |
|
594 } |
|
595 |
|
596 TInt err = KErrNone; |
|
597 |
|
598 // THwDeviceId hwDecoder = 0; |
|
599 // THwDeviceId hwPostProc = 0; |
|
600 |
|
601 // select decoder |
|
602 // TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
603 TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal |
|
604 if (err != KErrNone) |
|
605 { |
|
606 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
607 return EInconclusive; |
|
608 } |
|
609 |
|
610 // select post-processor |
|
611 // TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
612 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
613 if (err != KErrNone) |
|
614 { |
|
615 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
616 return EInconclusive; |
|
617 } |
|
618 |
|
619 // initialize CDevVideoPlay and wait for response |
|
620 // iError is set by the MdvpoInitComplete callback |
|
621 aDevVideoPlay.Initialize(); |
|
622 |
|
623 if (iError != KErrNone) |
|
624 { |
|
625 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
626 return EInconclusive; |
|
627 } |
|
628 |
|
629 // get pre-decoder buffer bytes |
|
630 TUint decBytes = aDevVideoPlay.PreDecoderBufferBytes(); |
|
631 |
|
632 // check against test data |
|
633 if (decBytes != KTestPreDecoderBytes) |
|
634 { |
|
635 ERR_PRINTF3(_L("PreDecoderBufferBytes() incorrect - gave %d (expected %d)"), |
|
636 decBytes, KTestPreDecoderBytes); |
|
637 ret = EFail; |
|
638 } |
|
639 else |
|
640 INFO_PRINTF1(_L("PreDecoderBufferBytes() called successfully")); |
|
641 |
|
642 return ret; |
|
643 } |
|
644 //------------------------------------------------------------------ |
|
645 |
|
646 void CTestDevVideoPlayPictureBufferBytes::MdvpoInitComplete(TInt aError) |
|
647 { |
|
648 INFO_PRINTF2(_L("CTestDevVideoPlayPictureBufferBytes::MdvpoInitComplete(): Error = %d"), aError); |
|
649 |
|
650 iError = aError; |
|
651 } |
|
652 |
|
653 CTestDevVideoPlayPictureBufferBytes::CTestDevVideoPlayPictureBufferBytes(const TDesC& aTestName, TTestType aTestType) |
|
654 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
655 { |
|
656 } |
|
657 |
|
658 CTestDevVideoPlayPictureBufferBytes* CTestDevVideoPlayPictureBufferBytes::NewL(const TDesC& aTestName, TTestType aTestType) |
|
659 { |
|
660 CTestDevVideoPlayPictureBufferBytes* self = new(ELeave) CTestDevVideoPlayPictureBufferBytes(aTestName, aTestType); |
|
661 return self; |
|
662 } |
|
663 |
|
664 TVerdict CTestDevVideoPlayPictureBufferBytes::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
665 { |
|
666 TVerdict ret = EPass; |
|
667 |
|
668 INFO_PRINTF1(_L("CMMFDevVideoPlay: PictureBufferBytes")); |
|
669 |
|
670 // expected results |
|
671 if (iTestType != ETestValid) |
|
672 { |
|
673 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
674 return EInconclusive; |
|
675 } |
|
676 |
|
677 TInt err = KErrNone; |
|
678 |
|
679 // THwDeviceId hwDecoder = 0; |
|
680 // THwDeviceId hwPostProc = 0; |
|
681 |
|
682 // select decoder |
|
683 // TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
684 TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal |
|
685 if (err != KErrNone) |
|
686 { |
|
687 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
688 return EInconclusive; |
|
689 } |
|
690 |
|
691 // select post-processor |
|
692 // TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
693 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
694 if (err != KErrNone) |
|
695 { |
|
696 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
697 return EInconclusive; |
|
698 } |
|
699 |
|
700 // initialize CDevVideoPlay and wait for response |
|
701 // iError is set by the MdvpoInitComplete callback |
|
702 aDevVideoPlay.Initialize(); |
|
703 |
|
704 if (iError != KErrNone) |
|
705 { |
|
706 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
707 return EInconclusive; |
|
708 } |
|
709 |
|
710 // get picture buffer bytes |
|
711 TUint picBytes = aDevVideoPlay.PictureBufferBytes(); |
|
712 |
|
713 // check against test data |
|
714 if (picBytes != KTestPictureBytes) |
|
715 { |
|
716 ERR_PRINTF3(_L("PictureBufferBytes() incorrect - gave %d (expected %d)"), |
|
717 picBytes, KTestPictureBytes); |
|
718 ret = EFail; |
|
719 } |
|
720 else |
|
721 INFO_PRINTF1(_L("PictureBufferBytes() called successfully")); |
|
722 |
|
723 return ret; |
|
724 } |
|
725 //------------------------------------------------------------------ |
|
726 |
|
727 void CTestDevVideoPlayGetPictureCounters::MdvpoInitComplete(TInt aError) |
|
728 { |
|
729 INFO_PRINTF2(_L("CTestDevVideoPlayGetPictureCounters::MdvpoInitComplete(): Error = %d"), aError); |
|
730 |
|
731 iError = aError; |
|
732 } |
|
733 |
|
734 CTestDevVideoPlayGetPictureCounters::CTestDevVideoPlayGetPictureCounters(const TDesC& aTestName, TTestType aTestType) |
|
735 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
736 { |
|
737 } |
|
738 |
|
739 CTestDevVideoPlayGetPictureCounters* CTestDevVideoPlayGetPictureCounters::NewL(const TDesC& aTestName, TTestType aTestType) |
|
740 { |
|
741 CTestDevVideoPlayGetPictureCounters* self = new(ELeave) CTestDevVideoPlayGetPictureCounters(aTestName, aTestType); |
|
742 return self; |
|
743 } |
|
744 |
|
745 TVerdict CTestDevVideoPlayGetPictureCounters::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
746 { |
|
747 TVerdict ret = EPass; |
|
748 TInt expErr = KErrNone; |
|
749 TBool selDec = ETrue; |
|
750 TBool selPost = ETrue; |
|
751 |
|
752 INFO_PRINTF1(_L("CMMFDevVideoPlay: GetPictureCounters")); |
|
753 |
|
754 // expected results |
|
755 switch(iTestType) |
|
756 { |
|
757 case ETestValid: |
|
758 expErr = KErrNone; |
|
759 break; |
|
760 case ETestDecoderOnly: |
|
761 selPost = EFalse; |
|
762 break; |
|
763 case ETestPostProcOnly: |
|
764 selDec = EFalse; |
|
765 break; |
|
766 default: |
|
767 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
768 return EInconclusive; |
|
769 } |
|
770 |
|
771 TInt err = KErrNone; |
|
772 |
|
773 THwDeviceId hwDecoder = 0; |
|
774 THwDeviceId hwPostProc = 0; |
|
775 |
|
776 // select decoder |
|
777 if (selDec) |
|
778 { |
|
779 TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
780 if (err != KErrNone) |
|
781 { |
|
782 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
783 return EInconclusive; |
|
784 } |
|
785 } |
|
786 |
|
787 // select post-processor |
|
788 if (selPost) |
|
789 { |
|
790 TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
791 if (err != KErrNone) |
|
792 { |
|
793 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
794 return EInconclusive; |
|
795 } |
|
796 } |
|
797 |
|
798 // initialize CDevVideoPlay and wait for response |
|
799 // iError is set by the MdvpoInitComplete callback |
|
800 aDevVideoPlay.Initialize(); |
|
801 |
|
802 if (iError != KErrNone) |
|
803 { |
|
804 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
805 return EInconclusive; |
|
806 } |
|
807 |
|
808 CMMFDevVideoPlay::TPictureCounters picCounts; |
|
809 |
|
810 // get picture counters from DevVideoPlay |
|
811 aDevVideoPlay.GetPictureCounters(picCounts); |
|
812 |
|
813 // N.B. PicturesSkipped is sum of decoder and post processor so |
|
814 // we have to add these |
|
815 CMMFDevVideoPlay::TPictureCounters testCounts = GetTestPictureCounters(); |
|
816 if (hwDecoder && hwPostProc) |
|
817 { |
|
818 // account for both decoder and post processor |
|
819 testCounts.iPicturesSkipped *= 2; |
|
820 } |
|
821 else if (hwPostProc) |
|
822 { |
|
823 // no decoded samples from a post processor |
|
824 testCounts.iPicturesDecoded = 0; |
|
825 } |
|
826 |
|
827 if (!ComparePictureCounters(picCounts, testCounts)) |
|
828 { |
|
829 ERR_PRINTF1(_L("GetPictureCounters() comparison with test data failed!")); |
|
830 ret = EFail; |
|
831 } |
|
832 else |
|
833 { |
|
834 INFO_PRINTF1(_L("GetPictureCounters() comparison with test data passed.")); |
|
835 INFO_PRINTF3(_L("GetPictureCounters(), %d = %d"), err, expErr); |
|
836 } |
|
837 |
|
838 return ret; |
|
839 } |
|
840 //------------------------------------------------------------------ |
|
841 |
|
842 void CTestDevVideoPlayGetBitstreamCounters::MdvpoInitComplete(TInt aError) |
|
843 { |
|
844 INFO_PRINTF2(_L("CTestDevVideoPlayGetBitstreamCounters::MdvpoInitComplete(): Error = %d"), aError); |
|
845 |
|
846 iError = aError; |
|
847 } |
|
848 |
|
849 CTestDevVideoPlayGetBitstreamCounters::CTestDevVideoPlayGetBitstreamCounters(const TDesC& aTestName, TTestType aTestType) |
|
850 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
851 { |
|
852 } |
|
853 |
|
854 CTestDevVideoPlayGetBitstreamCounters* CTestDevVideoPlayGetBitstreamCounters::NewL(const TDesC& aTestName, TTestType aTestType) |
|
855 { |
|
856 CTestDevVideoPlayGetBitstreamCounters* self = new(ELeave) CTestDevVideoPlayGetBitstreamCounters(aTestName, aTestType); |
|
857 return self; |
|
858 } |
|
859 |
|
860 TVerdict CTestDevVideoPlayGetBitstreamCounters::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
861 { |
|
862 TVerdict ret = EPass; |
|
863 TInt expErr = KErrNone; |
|
864 |
|
865 INFO_PRINTF1(_L("CMMFDevVideoPlay: GetBitstreamCounters")); |
|
866 |
|
867 // expected results |
|
868 if (iTestType != ETestValid) |
|
869 { |
|
870 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
871 return EInconclusive; |
|
872 } |
|
873 |
|
874 TInt err = KErrNone; |
|
875 |
|
876 // THwDeviceId hwDecoder = 0; |
|
877 // THwDeviceId hwPostProc = 0; |
|
878 |
|
879 // select decoder |
|
880 // TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
881 TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));// EABI warning removal |
|
882 if (err != KErrNone) |
|
883 { |
|
884 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
885 return EInconclusive; |
|
886 } |
|
887 |
|
888 // select post-processor |
|
889 // TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
890 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
891 if (err != KErrNone) |
|
892 { |
|
893 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
894 return EInconclusive; |
|
895 } |
|
896 |
|
897 // initialize CDevVideoPlay and wait for response |
|
898 // iError is set by the MdvpoInitComplete callback |
|
899 aDevVideoPlay.Initialize(); |
|
900 |
|
901 if (iError != KErrNone) |
|
902 { |
|
903 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
904 return EInconclusive; |
|
905 } |
|
906 |
|
907 CMMFDevVideoPlay::TBitstreamCounters bitCounts; |
|
908 |
|
909 // get bitstream counters from DevVideoPlay |
|
910 aDevVideoPlay.GetBitstreamCounters(bitCounts); |
|
911 |
|
912 if (!CompareBitstreamCounters(bitCounts, GetTestBitstreamCounters())) |
|
913 { |
|
914 ERR_PRINTF1(_L("GetBitstreamCounters() comparison with test data failed!")); |
|
915 ret = EFail; |
|
916 } |
|
917 else |
|
918 { |
|
919 INFO_PRINTF1(_L("GetBitstreamCounters() comparison with test data passed.")); |
|
920 INFO_PRINTF3(_L("GetBitstreamCounters(), %d = %d"), err, expErr); |
|
921 } |
|
922 |
|
923 return ret; |
|
924 } |
|
925 //------------------------------------------------------------------ |
|
926 |
|
927 void CTestDevVideoPlayNumFreeBuffers::MdvpoInitComplete(TInt aError) |
|
928 { |
|
929 INFO_PRINTF2(_L("CTestDevVideoPlayNumFreeBuffers::MdvpoInitComplete(): Error = %d"), aError); |
|
930 |
|
931 iError = aError; |
|
932 } |
|
933 |
|
934 CTestDevVideoPlayNumFreeBuffers::CTestDevVideoPlayNumFreeBuffers(const TDesC& aTestName, TTestType aTestType) |
|
935 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
936 { |
|
937 } |
|
938 |
|
939 CTestDevVideoPlayNumFreeBuffers* CTestDevVideoPlayNumFreeBuffers::NewL(const TDesC& aTestName, TTestType aTestType) |
|
940 { |
|
941 CTestDevVideoPlayNumFreeBuffers* self = new(ELeave) CTestDevVideoPlayNumFreeBuffers(aTestName, aTestType); |
|
942 return self; |
|
943 } |
|
944 |
|
945 TVerdict CTestDevVideoPlayNumFreeBuffers::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
946 { |
|
947 TVerdict ret = EPass; |
|
948 |
|
949 INFO_PRINTF1(_L("CMMFDevVideoPlay: NumFreeBuffers")); |
|
950 |
|
951 // expected results |
|
952 if (iTestType != ETestValid) |
|
953 { |
|
954 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
955 return EInconclusive; |
|
956 } |
|
957 |
|
958 TInt err = KErrNone; |
|
959 |
|
960 // THwDeviceId hwDecoder = 0; |
|
961 // THwDeviceId hwPostProc = 0; |
|
962 |
|
963 // select decoder |
|
964 // TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
965 TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal |
|
966 if (err != KErrNone) |
|
967 { |
|
968 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
969 return EInconclusive; |
|
970 } |
|
971 |
|
972 // select post-processor |
|
973 // TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
974 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
975 if (err != KErrNone) |
|
976 { |
|
977 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
978 return EInconclusive; |
|
979 } |
|
980 |
|
981 // initialize CDevVideoPlay and wait for response |
|
982 // iError is set by the MdvpoInitComplete callback |
|
983 aDevVideoPlay.Initialize(); |
|
984 |
|
985 if (iError != KErrNone) |
|
986 { |
|
987 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
988 return EInconclusive; |
|
989 } |
|
990 |
|
991 TUint numBuffers = 0; |
|
992 |
|
993 // get number of free buffers from DevVideoPlay |
|
994 numBuffers = aDevVideoPlay.NumFreeBuffers(); |
|
995 |
|
996 if (numBuffers != KTestNumFreeBuffers) |
|
997 { |
|
998 ERR_PRINTF1(_L("NumFreeBuffers() comparison with test data failed!")); |
|
999 ret = EFail; |
|
1000 } |
|
1001 else |
|
1002 { |
|
1003 INFO_PRINTF1(_L("NumFreeBuffers() comparison with test data passed.")); |
|
1004 INFO_PRINTF3(_L("NumFreeBuffers(), %d = %d"), numBuffers, KTestNumFreeBuffers); |
|
1005 } |
|
1006 return ret; |
|
1007 } |
|
1008 //------------------------------------------------------------------ |
|
1009 |
|
1010 void CTestDevVideoPlaySetComplexityLevel::MdvpoInitComplete(TInt aError) |
|
1011 { |
|
1012 INFO_PRINTF2(_L("CTestDevVideoPlaySetComplexityLevel::MdvpoInitComplete(): Error = %d"), aError); |
|
1013 |
|
1014 iError = aError; |
|
1015 } |
|
1016 |
|
1017 CTestDevVideoPlaySetComplexityLevel::CTestDevVideoPlaySetComplexityLevel(const TDesC& aTestName, TTestType aTestType) |
|
1018 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
1019 { |
|
1020 } |
|
1021 |
|
1022 CTestDevVideoPlaySetComplexityLevel* CTestDevVideoPlaySetComplexityLevel::NewL(const TDesC& aTestName, TTestType aTestType) |
|
1023 { |
|
1024 CTestDevVideoPlaySetComplexityLevel* self = new(ELeave) CTestDevVideoPlaySetComplexityLevel(aTestName, aTestType); |
|
1025 return self; |
|
1026 } |
|
1027 |
|
1028 TVerdict CTestDevVideoPlaySetComplexityLevel::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
1029 { |
|
1030 TVerdict ret = EPass; |
|
1031 |
|
1032 INFO_PRINTF1(_L("CMMFDevVideoPlay: SetComplexityLevel")); |
|
1033 |
|
1034 // expected results |
|
1035 if (iTestType != ETestValid) |
|
1036 { |
|
1037 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
1038 return EInconclusive; |
|
1039 } |
|
1040 |
|
1041 TInt err = KErrNone; |
|
1042 |
|
1043 THwDeviceId hwDecoder = 0; |
|
1044 THwDeviceId hwPostProc = 0; |
|
1045 |
|
1046 // select decoder |
|
1047 TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
1048 if (err != KErrNone) |
|
1049 { |
|
1050 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
1051 return EInconclusive; |
|
1052 } |
|
1053 |
|
1054 // select post-processor |
|
1055 TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
1056 if (err != KErrNone) |
|
1057 { |
|
1058 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
1059 return EInconclusive; |
|
1060 } |
|
1061 |
|
1062 // initialize CDevVideoPlay and wait for response |
|
1063 // iError is set by the MdvpoInitComplete callback |
|
1064 aDevVideoPlay.Initialize(); |
|
1065 |
|
1066 if (iError != KErrNone) |
|
1067 { |
|
1068 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
1069 return EInconclusive; |
|
1070 } |
|
1071 |
|
1072 // set complexity level on decoder |
|
1073 aDevVideoPlay.SetComplexityLevel(hwDecoder, KTestComplexityLevel1); |
|
1074 |
|
1075 // set complexity level on post-processor |
|
1076 aDevVideoPlay.SetComplexityLevel(hwPostProc, KTestComplexityLevel2); |
|
1077 |
|
1078 // if no PANIC then test has passed |
|
1079 INFO_PRINTF3(_L("SetComplexityLevel(), %d, %d"), KTestComplexityLevel1, KTestComplexityLevel2); |
|
1080 |
|
1081 return ret; |
|
1082 } |
|
1083 //------------------------------------------------------------------ |
|
1084 |
|
1085 void CTestDevVideoPlayNumComplexityLevels::MdvpoInitComplete(TInt aError) |
|
1086 { |
|
1087 INFO_PRINTF2(_L("CTestDevVideoPlayNumComplexityLevels::MdvpoInitComplete(): Error = %d"), aError); |
|
1088 |
|
1089 iError = aError; |
|
1090 } |
|
1091 |
|
1092 CTestDevVideoPlayNumComplexityLevels::CTestDevVideoPlayNumComplexityLevels(const TDesC& aTestName, TTestType aTestType) |
|
1093 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
1094 { |
|
1095 } |
|
1096 |
|
1097 CTestDevVideoPlayNumComplexityLevels* CTestDevVideoPlayNumComplexityLevels::NewL(const TDesC& aTestName, TTestType aTestType) |
|
1098 { |
|
1099 CTestDevVideoPlayNumComplexityLevels* self = new(ELeave) CTestDevVideoPlayNumComplexityLevels(aTestName, aTestType); |
|
1100 return self; |
|
1101 } |
|
1102 |
|
1103 TVerdict CTestDevVideoPlayNumComplexityLevels::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
1104 { |
|
1105 TVerdict ret = EPass; |
|
1106 |
|
1107 INFO_PRINTF1(_L("CMMFDevVideoPlay: NumComplexityLevels")); |
|
1108 |
|
1109 // expected results |
|
1110 if (iTestType != ETestValid) |
|
1111 { |
|
1112 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
1113 return EInconclusive; |
|
1114 } |
|
1115 |
|
1116 TInt err = KErrNone; |
|
1117 |
|
1118 THwDeviceId hwDecoder = 0; |
|
1119 THwDeviceId hwPostProc = 0; |
|
1120 |
|
1121 // select decoder |
|
1122 TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
1123 if (err != KErrNone) |
|
1124 { |
|
1125 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
1126 return EInconclusive; |
|
1127 } |
|
1128 |
|
1129 // select post-processor |
|
1130 TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
1131 if (err != KErrNone) |
|
1132 { |
|
1133 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
1134 return EInconclusive; |
|
1135 } |
|
1136 |
|
1137 // initialize CDevVideoPlay and wait for response |
|
1138 // iError is set by the MdvpoInitComplete callback |
|
1139 aDevVideoPlay.Initialize(); |
|
1140 |
|
1141 if (iError != KErrNone) |
|
1142 { |
|
1143 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
1144 return EInconclusive; |
|
1145 } |
|
1146 |
|
1147 // get num complexity levels on decoder |
|
1148 TUint levs1 = aDevVideoPlay.NumComplexityLevels(hwDecoder); |
|
1149 |
|
1150 // get num complexity levels on post-processor |
|
1151 TUint levs2 = aDevVideoPlay.NumComplexityLevels(hwPostProc); |
|
1152 |
|
1153 // check return values against test data |
|
1154 if (levs1 != KTestNumComplexityLevels1 || levs2 != KTestNumComplexityLevels2) |
|
1155 { |
|
1156 ERR_PRINTF3(_L("Error - comparison against test data failed! (%d, %d)"), levs1, levs2); |
|
1157 } |
|
1158 else |
|
1159 { |
|
1160 INFO_PRINTF3(_L("NumComplexityLevels(), %d, %d"), levs1, levs2); |
|
1161 } |
|
1162 |
|
1163 return ret; |
|
1164 } |
|
1165 //------------------------------------------------------------------ |
|
1166 |
|
1167 void CTestDevVideoPlayGetComplexityLevelInfo::MdvpoInitComplete(TInt aError) |
|
1168 { |
|
1169 INFO_PRINTF2(_L("CTestDevVideoPlayGetComplexityLevelInfo::MdvpoInitComplete(): Error = %d"), aError); |
|
1170 |
|
1171 iError = aError; |
|
1172 } |
|
1173 |
|
1174 CTestDevVideoPlayGetComplexityLevelInfo::CTestDevVideoPlayGetComplexityLevelInfo(const TDesC& aTestName, TTestType aTestType) |
|
1175 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
1176 { |
|
1177 } |
|
1178 |
|
1179 CTestDevVideoPlayGetComplexityLevelInfo* CTestDevVideoPlayGetComplexityLevelInfo::NewL(const TDesC& aTestName, TTestType aTestType) |
|
1180 { |
|
1181 CTestDevVideoPlayGetComplexityLevelInfo* self = new(ELeave) CTestDevVideoPlayGetComplexityLevelInfo(aTestName, aTestType); |
|
1182 return self; |
|
1183 } |
|
1184 |
|
1185 TVerdict CTestDevVideoPlayGetComplexityLevelInfo::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
1186 { |
|
1187 TVerdict ret = EPass; |
|
1188 |
|
1189 INFO_PRINTF1(_L("CMMFDevVideoPlay: GetComplexityLevelInfo")); |
|
1190 |
|
1191 // expected results |
|
1192 if (iTestType != ETestValid) |
|
1193 { |
|
1194 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
1195 return EInconclusive; |
|
1196 } |
|
1197 |
|
1198 TInt err = KErrNone; |
|
1199 |
|
1200 THwDeviceId hwDecoder = 0; |
|
1201 THwDeviceId hwPostProc = 0; |
|
1202 |
|
1203 // select decoder |
|
1204 TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
1205 if (err != KErrNone) |
|
1206 { |
|
1207 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
1208 return EInconclusive; |
|
1209 } |
|
1210 |
|
1211 // select post-processor |
|
1212 TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
1213 if (err != KErrNone) |
|
1214 { |
|
1215 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
1216 return EInconclusive; |
|
1217 } |
|
1218 |
|
1219 // initialize CDevVideoPlay and wait for response |
|
1220 // iError is set by the MdvpoInitComplete callback |
|
1221 aDevVideoPlay.Initialize(); |
|
1222 |
|
1223 if (iError != KErrNone) |
|
1224 { |
|
1225 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
1226 return EInconclusive; |
|
1227 } |
|
1228 |
|
1229 CMMFDevVideoPlay::TComplexityLevelInfo levInfo1; |
|
1230 CMMFDevVideoPlay::TComplexityLevelInfo levInfo2; |
|
1231 |
|
1232 // get complexity level info on decoder |
|
1233 aDevVideoPlay.GetComplexityLevelInfo(hwDecoder, KTestComplexityLevel1, levInfo1); |
|
1234 |
|
1235 // get complexity level info on post-processor |
|
1236 aDevVideoPlay.GetComplexityLevelInfo(hwPostProc, KTestComplexityLevel2, levInfo2); |
|
1237 |
|
1238 CMMFDevVideoPlay::TComplexityLevelInfo testInfo1 = GetTestLevelInfo(KTestComplexityLevel1); |
|
1239 CMMFDevVideoPlay::TComplexityLevelInfo testInfo2 = GetTestLevelInfo(KTestComplexityLevel2); |
|
1240 |
|
1241 // check return values against test data |
|
1242 if (!CompareLevelInfos(levInfo1, testInfo1) || !CompareLevelInfos(levInfo2, testInfo2)) |
|
1243 { |
|
1244 ERR_PRINTF1(_L("Error - comparison against test data failed!")); |
|
1245 } |
|
1246 else |
|
1247 { |
|
1248 INFO_PRINTF1(_L("Comparison against test data passed ok.")); |
|
1249 INFO_PRINTF1(_L("GetComplexityLevelInfo() called successfully")); |
|
1250 } |
|
1251 |
|
1252 return ret; |
|
1253 } |
|
1254 //------------------------------------------------------------------ |
|
1255 |
|
1256 void CTestDevVideoPlayGetBuffer::MdvpoInitComplete(TInt aError) |
|
1257 { |
|
1258 INFO_PRINTF2(_L("CTestDevVideoPlayGetBuffer::MdvpoInitComplete(): Error = %d"), aError); |
|
1259 |
|
1260 iError = aError; |
|
1261 } |
|
1262 |
|
1263 void CTestDevVideoPlayGetBuffer::MdvpoNewBuffers() |
|
1264 { |
|
1265 INFO_PRINTF1(_L("CTestDevVideoPlayGetBuffer::MdvpoNewBuffers()")); |
|
1266 iCalledBack = ETrue; |
|
1267 } |
|
1268 |
|
1269 CTestDevVideoPlayGetBuffer::CTestDevVideoPlayGetBuffer(const TDesC& aTestName, TTestType aTestType) |
|
1270 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
1271 { |
|
1272 } |
|
1273 |
|
1274 CTestDevVideoPlayGetBuffer* CTestDevVideoPlayGetBuffer::NewL(const TDesC& aTestName, TTestType aTestType) |
|
1275 { |
|
1276 CTestDevVideoPlayGetBuffer* self = new(ELeave) CTestDevVideoPlayGetBuffer(aTestName, aTestType); |
|
1277 return self; |
|
1278 } |
|
1279 |
|
1280 TVerdict CTestDevVideoPlayGetBuffer::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
1281 { |
|
1282 TVerdict ret = EPass; |
|
1283 TInt expErr = KErrNone; |
|
1284 |
|
1285 INFO_PRINTF1(_L("CMMFDevVideoPlay: GetBuffer")); |
|
1286 |
|
1287 // expected results |
|
1288 if (iTestType != ETestValid) |
|
1289 { |
|
1290 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
1291 return EInconclusive; |
|
1292 } |
|
1293 |
|
1294 TInt err = KErrNone; |
|
1295 |
|
1296 // THwDeviceId hwDecoder = 0; |
|
1297 // THwDeviceId hwPostProc = 0; |
|
1298 |
|
1299 // select decoder |
|
1300 // TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
1301 TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal |
|
1302 if (err != KErrNone) |
|
1303 { |
|
1304 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
1305 return EInconclusive; |
|
1306 } |
|
1307 |
|
1308 // select post-processor |
|
1309 // TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
1310 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
1311 if (err != KErrNone) |
|
1312 { |
|
1313 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
1314 return EInconclusive; |
|
1315 } |
|
1316 |
|
1317 // initialize CDevVideoPlay and wait for response |
|
1318 // iError is set by the MdvpoInitComplete callback |
|
1319 aDevVideoPlay.Initialize(); |
|
1320 |
|
1321 if (iError != KErrNone) |
|
1322 { |
|
1323 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
1324 return EInconclusive; |
|
1325 } |
|
1326 |
|
1327 TVideoInputBuffer* newBuff = NULL; |
|
1328 |
|
1329 // get a buffer of a certain size from DevVideoPlay |
|
1330 TRAP(err, newBuff = aDevVideoPlay.GetBufferL(KTestBufferSize) ); |
|
1331 // callback will occur and newBuff will be set to new buffer |
|
1332 |
|
1333 if (err != expErr) |
|
1334 { |
|
1335 ERR_PRINTF3(_L("GetBufferL() gave error %d (expected %d)"),err, expErr); |
|
1336 ret = EFail; |
|
1337 } |
|
1338 else |
|
1339 { |
|
1340 TBool buffSuccess = EFalse; |
|
1341 |
|
1342 // check callback has been called and buffer is correct |
|
1343 if (newBuff && iCalledBack) |
|
1344 { |
|
1345 TTimeIntervalMicroSeconds testTime(KTestBufferSize); |
|
1346 if ( (newBuff->iDecodingTimestamp == testTime) && |
|
1347 (newBuff->iOptions == KTestBufferOptions) && |
|
1348 (newBuff->iData == KTestBufferString) ) |
|
1349 { |
|
1350 buffSuccess = ETrue; |
|
1351 } |
|
1352 } |
|
1353 |
|
1354 if (!buffSuccess) |
|
1355 { |
|
1356 ERR_PRINTF1(_L("Received buffer is corrupt!")); |
|
1357 ret = EFail; |
|
1358 } |
|
1359 else |
|
1360 { |
|
1361 INFO_PRINTF1(_L("Buffer received correctly")); |
|
1362 INFO_PRINTF3(_L("GetBuffer(), %d = %d"), err, expErr); |
|
1363 } |
|
1364 } |
|
1365 return ret; |
|
1366 } |
|
1367 //------------------------------------------------------------------ |
|
1368 |
|
1369 void CTestDevVideoPlayWriteCodedData::MdvpoInitComplete(TInt aError) |
|
1370 { |
|
1371 INFO_PRINTF2(_L("CTestDevVideoPlayWriteCodedData::MdvpoInitComplete(): Error = %d"), aError); |
|
1372 |
|
1373 iError = aError; |
|
1374 } |
|
1375 |
|
1376 CTestDevVideoPlayWriteCodedData::CTestDevVideoPlayWriteCodedData(const TDesC& aTestName, TTestType aTestType) |
|
1377 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
1378 { |
|
1379 } |
|
1380 |
|
1381 CTestDevVideoPlayWriteCodedData* CTestDevVideoPlayWriteCodedData::NewL(const TDesC& aTestName, TTestType aTestType) |
|
1382 { |
|
1383 CTestDevVideoPlayWriteCodedData* self = new(ELeave) CTestDevVideoPlayWriteCodedData(aTestName, aTestType); |
|
1384 return self; |
|
1385 } |
|
1386 |
|
1387 TVerdict CTestDevVideoPlayWriteCodedData::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
1388 { |
|
1389 TVerdict ret = EPass; |
|
1390 TInt expErr = KErrNone; |
|
1391 |
|
1392 INFO_PRINTF1(_L("CMMFDevVideoPlay: WriteCodedData")); |
|
1393 |
|
1394 // expected results |
|
1395 if (iTestType != ETestValid) |
|
1396 { |
|
1397 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
1398 return EInconclusive; |
|
1399 } |
|
1400 |
|
1401 TInt err = KErrNone; |
|
1402 |
|
1403 // THwDeviceId hwDecoder = 0; |
|
1404 // THwDeviceId hwPostProc = 0; |
|
1405 |
|
1406 // select decoder |
|
1407 // TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
1408 TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal |
|
1409 if (err != KErrNone) |
|
1410 { |
|
1411 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
1412 return EInconclusive; |
|
1413 } |
|
1414 |
|
1415 // select post-processor |
|
1416 // TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
1417 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
1418 if (err != KErrNone) |
|
1419 { |
|
1420 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
1421 return EInconclusive; |
|
1422 } |
|
1423 |
|
1424 // initialize CDevVideoPlay and wait for response |
|
1425 // iError is set by the MdvpoInitComplete callback |
|
1426 aDevVideoPlay.Initialize(); |
|
1427 |
|
1428 if (iError != KErrNone) |
|
1429 { |
|
1430 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
1431 return EInconclusive; |
|
1432 } |
|
1433 |
|
1434 // construct a video input buffer structure with a valid timestamp and |
|
1435 // write this DevVideoPlay. Call will leave on error. |
|
1436 TVideoInputBuffer* newBuff = NULL; |
|
1437 TPtrC8 testBufferStringPtr(KTestBufferString); |
|
1438 TRAP(err, newBuff = aDevVideoPlay.GetBufferL(testBufferStringPtr.Length())); |
|
1439 if (err) |
|
1440 { |
|
1441 ERR_PRINTF1(_L("Error - couldn't get buffer from DevVideoPlay")); |
|
1442 return EInconclusive; |
|
1443 } |
|
1444 |
|
1445 // initialize newBuff with test data |
|
1446 newBuff->iOptions = KTestBufferOptions; |
|
1447 newBuff->iDecodingTimestamp = KTestBufferSize; |
|
1448 newBuff->iData.Zero(); |
|
1449 newBuff->iData.Append(testBufferStringPtr); |
|
1450 |
|
1451 // write buffer to DevVideoPlay |
|
1452 TRAP(err, aDevVideoPlay.WriteCodedDataL(newBuff) ) |
|
1453 |
|
1454 if (err != expErr) |
|
1455 { |
|
1456 ERR_PRINTF3(_L("WriteCodedDataL() gave error %d (expected %d)"),err, expErr); |
|
1457 ret = EFail; |
|
1458 } |
|
1459 else |
|
1460 { |
|
1461 INFO_PRINTF1(_L("Coded data sent successfully")); |
|
1462 INFO_PRINTF3(_L("WriteCodedDataL(), %d = %d"), err, expErr); |
|
1463 } |
|
1464 return ret; |
|
1465 } |
|
1466 //------------------------------------------------------------------ |
|
1467 |
|
1468 void CTestDevVideoPlayScanAndCopyCodedData::MdvpoInitComplete(TInt aError) |
|
1469 { |
|
1470 INFO_PRINTF2(_L("CTestDevVideoPlayWriteCodedData::MdvpoInitComplete(): Error = %d"), aError); |
|
1471 |
|
1472 iError = aError; |
|
1473 } |
|
1474 |
|
1475 CTestDevVideoPlayScanAndCopyCodedData::CTestDevVideoPlayScanAndCopyCodedData(const TDesC& aTestName, TTestType aTestType) |
|
1476 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
1477 { |
|
1478 } |
|
1479 |
|
1480 CTestDevVideoPlayScanAndCopyCodedData* CTestDevVideoPlayScanAndCopyCodedData::NewL(const TDesC& aTestName, TTestType aTestType) |
|
1481 { |
|
1482 CTestDevVideoPlayScanAndCopyCodedData* self = new(ELeave) CTestDevVideoPlayScanAndCopyCodedData(aTestName, aTestType); |
|
1483 return self; |
|
1484 } |
|
1485 |
|
1486 TVerdict CTestDevVideoPlayScanAndCopyCodedData::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
1487 { |
|
1488 TVerdict ret = EPass; |
|
1489 TInt expErr = KErrNone; |
|
1490 |
|
1491 INFO_PRINTF1(_L("MMMFVideoPlayHwDeviceExtensionScanCopy: ScanAndCopyCodedDataL")); |
|
1492 |
|
1493 // expected results |
|
1494 if (iTestType != ETestValid) |
|
1495 { |
|
1496 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
1497 return EInconclusive; |
|
1498 } |
|
1499 |
|
1500 TInt err = KErrNone; |
|
1501 |
|
1502 THwDeviceId hwDecoder = 0; |
|
1503 |
|
1504 // select decoder |
|
1505 TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
1506 if (err != KErrNone) |
|
1507 { |
|
1508 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
1509 return EInconclusive; |
|
1510 } |
|
1511 |
|
1512 // select post-processor |
|
1513 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
1514 if (err != KErrNone) |
|
1515 { |
|
1516 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
1517 return EInconclusive; |
|
1518 } |
|
1519 |
|
1520 // initialize CDevVideoPlay and wait for response |
|
1521 // iError is set by the MdvpoInitComplete callback |
|
1522 aDevVideoPlay.Initialize(); |
|
1523 |
|
1524 if (iError != KErrNone) |
|
1525 { |
|
1526 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
1527 return EInconclusive; |
|
1528 } |
|
1529 |
|
1530 |
|
1531 // construct a video input buffer structure with a valid timestamp and |
|
1532 // write this DevVideoPlay. Call will leave on error. |
|
1533 TVideoInputBuffer* newBuff = NULL; |
|
1534 TPtrC8 testBufferStringPtr(KTestBufferString); |
|
1535 TRAP(err, newBuff = aDevVideoPlay.GetBufferL(testBufferStringPtr.Length())); |
|
1536 if (err) |
|
1537 { |
|
1538 ERR_PRINTF1(_L("Error - couldn't get buffer from DevVideoPlay")); |
|
1539 return EInconclusive; |
|
1540 } |
|
1541 |
|
1542 //clean out pre-set stuff from buffer |
|
1543 newBuff->iData.Zero(); |
|
1544 //set ptr to test data |
|
1545 TPtrC8 testBufferString(KTestBufferString); |
|
1546 HBufC8* bufferDataArea = testBufferString.AllocL(); |
|
1547 CleanupStack::PushL(bufferDataArea); |
|
1548 TPtr8 dataAreaPtr = bufferDataArea->Des(); |
|
1549 TFramePortion framePortion = EFramePortionEndFragment; |
|
1550 |
|
1551 MMMFVideoPlayHwDeviceExtensionScanCopy* ciOne = static_cast<MMMFVideoPlayHwDeviceExtensionScanCopy*>(aDevVideoPlay.CustomInterface(hwDecoder, KUidDevVideoPlayHwDeviceExtensionScanCopy)); |
|
1552 |
|
1553 TInt consumed = 0; |
|
1554 // write buffer to DevVideoPlay using new interface |
|
1555 TRAP(err, ciOne->ScanAndCopyCodedDataL(dataAreaPtr, newBuff, consumed, framePortion)); |
|
1556 |
|
1557 //compare buffer to test data |
|
1558 if ((newBuff->iData != KTestBufferString) || consumed != newBuff->iData.Length()) |
|
1559 { |
|
1560 err = KErrCorrupt; |
|
1561 } |
|
1562 |
|
1563 if (err != expErr) |
|
1564 { |
|
1565 ERR_PRINTF3(_L("ScanAndCopyCodedDataL() gave error %d (expected %d)"),err, expErr); |
|
1566 ret = EFail; |
|
1567 } |
|
1568 else |
|
1569 { |
|
1570 INFO_PRINTF1(_L("Coded data sent successfully")); |
|
1571 INFO_PRINTF3(_L("ScanAndCopyCodedDataL(), %d = %d"), err, expErr); |
|
1572 } |
|
1573 CleanupStack::PopAndDestroy(bufferDataArea); |
|
1574 return ret; |
|
1575 } |
|
1576 |
|
1577 //------------------------------------------------------------------ |
|
1578 |
|
1579 void CTestDevVideoPlayExtensionWriteCodedData::MdvpoInitComplete(TInt aError) |
|
1580 { |
|
1581 INFO_PRINTF2(_L("CTestDevVideoPlayWriteCodedData::MdvpoInitComplete(): Error = %d"), aError); |
|
1582 |
|
1583 iError = aError; |
|
1584 } |
|
1585 |
|
1586 CTestDevVideoPlayExtensionWriteCodedData::CTestDevVideoPlayExtensionWriteCodedData(const TDesC& aTestName, TTestType aTestType) |
|
1587 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
1588 { |
|
1589 } |
|
1590 |
|
1591 CTestDevVideoPlayExtensionWriteCodedData* CTestDevVideoPlayExtensionWriteCodedData::NewL(const TDesC& aTestName, TTestType aTestType) |
|
1592 { |
|
1593 CTestDevVideoPlayExtensionWriteCodedData* self = new(ELeave) CTestDevVideoPlayExtensionWriteCodedData(aTestName, aTestType); |
|
1594 return self; |
|
1595 } |
|
1596 |
|
1597 TVerdict CTestDevVideoPlayExtensionWriteCodedData::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
1598 { |
|
1599 TVerdict ret = EPass; |
|
1600 TInt expErr = KErrNone; |
|
1601 |
|
1602 INFO_PRINTF1(_L("MMMFVideoPlayHwDeviceExtensionScanCopy: WriteCodedData")); |
|
1603 |
|
1604 // expected results |
|
1605 if (iTestType != ETestValid) |
|
1606 { |
|
1607 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
1608 return EInconclusive; |
|
1609 } |
|
1610 |
|
1611 TInt err = KErrNone; |
|
1612 |
|
1613 THwDeviceId hwDecoder = 0; |
|
1614 |
|
1615 // select decoder |
|
1616 TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
1617 |
|
1618 if (err != KErrNone) |
|
1619 { |
|
1620 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
1621 return EInconclusive; |
|
1622 } |
|
1623 |
|
1624 // select post-processor |
|
1625 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
1626 if (err != KErrNone) |
|
1627 { |
|
1628 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
1629 return EInconclusive; |
|
1630 } |
|
1631 |
|
1632 // initialize CDevVideoPlay and wait for response |
|
1633 // iError is set by the MdvpoInitComplete callback |
|
1634 aDevVideoPlay.Initialize(); |
|
1635 |
|
1636 if (iError != KErrNone) |
|
1637 { |
|
1638 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
1639 return EInconclusive; |
|
1640 } |
|
1641 |
|
1642 // construct a video input buffer structure with a valid timestamp and |
|
1643 // write this DevVideoPlay. Call will leave on error. |
|
1644 TVideoInputBuffer* newBuff = NULL; |
|
1645 TPtrC8 testBufferStringPtr(KTestBufferString); |
|
1646 TRAP(err, newBuff = aDevVideoPlay.GetBufferL(testBufferStringPtr.Length())); |
|
1647 if (err) |
|
1648 { |
|
1649 ERR_PRINTF1(_L("Error - couldn't get buffer from DevVideoPlay")); |
|
1650 return EInconclusive; |
|
1651 } |
|
1652 |
|
1653 // initialize newBuff with test data |
|
1654 newBuff->iOptions = KTestBufferOptions; |
|
1655 newBuff->iDecodingTimestamp = KTestBufferSize; |
|
1656 newBuff->iData.Zero(); |
|
1657 newBuff->iData.Append(testBufferStringPtr); |
|
1658 |
|
1659 TFramePortion framePortion = EFramePortionEndFragment; |
|
1660 |
|
1661 MMMFVideoPlayHwDeviceExtensionScanCopy* ciOne = static_cast<MMMFVideoPlayHwDeviceExtensionScanCopy*>(aDevVideoPlay.CustomInterface(hwDecoder, KUidDevVideoPlayHwDeviceExtensionScanCopy)); |
|
1662 |
|
1663 // write buffer to DevVideoPlay using new interface |
|
1664 TRAP(err, ciOne->WriteCodedDataL(newBuff, framePortion)); |
|
1665 |
|
1666 if (err != expErr) |
|
1667 { |
|
1668 ERR_PRINTF3(_L("WriteCodedDataL() gave error %d (expected %d)"),err, expErr); |
|
1669 ret = EFail; |
|
1670 } |
|
1671 else |
|
1672 { |
|
1673 INFO_PRINTF1(_L("Coded data sent successfully")); |
|
1674 INFO_PRINTF3(_L("WriteCodedDataL(), %d = %d"), err, expErr); |
|
1675 } |
|
1676 return ret; |
|
1677 } |
|
1678 |
|
1679 //------------------------------------------------------------------ |
|
1680 |
|
1681 void CTestDevVideoPlayWritePicture::MdvpoInitComplete(TInt aError) |
|
1682 { |
|
1683 INFO_PRINTF2(_L("CTestDevVideoPlayWritePicture::MdvpoInitComplete(): Error = %d"), aError); |
|
1684 |
|
1685 iError = aError; |
|
1686 } |
|
1687 |
|
1688 void CTestDevVideoPlayWritePicture::MdvpoReturnPicture(TVideoPicture* aPicture) |
|
1689 { |
|
1690 INFO_PRINTF1(_L("CTestDevVideoPlayWritePicture::MdvpoReturnPicture()")); |
|
1691 |
|
1692 iPicture = aPicture; |
|
1693 } |
|
1694 |
|
1695 CTestDevVideoPlayWritePicture::CTestDevVideoPlayWritePicture(const TDesC& aTestName, TTestType aTestType) |
|
1696 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
1697 { |
|
1698 } |
|
1699 |
|
1700 CTestDevVideoPlayWritePicture* CTestDevVideoPlayWritePicture::NewL(const TDesC& aTestName, TTestType aTestType) |
|
1701 { |
|
1702 CTestDevVideoPlayWritePicture* self = new(ELeave) CTestDevVideoPlayWritePicture(aTestName, aTestType); |
|
1703 return self; |
|
1704 } |
|
1705 |
|
1706 TVerdict CTestDevVideoPlayWritePicture::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
1707 { |
|
1708 TVerdict ret = EPass; |
|
1709 TInt expErr = KErrNone; |
|
1710 |
|
1711 INFO_PRINTF1(_L("CMMFDevVideoPlay: WritePicture")); |
|
1712 |
|
1713 // expected results |
|
1714 if (iTestType != ETestValid) |
|
1715 { |
|
1716 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
1717 return EInconclusive; |
|
1718 } |
|
1719 |
|
1720 TInt err = KErrNone; |
|
1721 |
|
1722 // THwDeviceId hwDecoder = 0; |
|
1723 // THwDeviceId hwPostProc = 0; |
|
1724 |
|
1725 // select decoder |
|
1726 // TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
1727 TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal |
|
1728 if (err != KErrNone) |
|
1729 { |
|
1730 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
1731 return EInconclusive; |
|
1732 } |
|
1733 |
|
1734 // select post-processor |
|
1735 // TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
1736 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
1737 if (err != KErrNone) |
|
1738 { |
|
1739 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
1740 return EInconclusive; |
|
1741 } |
|
1742 |
|
1743 // initialize CDevVideoPlay and wait for response |
|
1744 // iError is set by the MdvpoInitComplete callback |
|
1745 aDevVideoPlay.Initialize(); |
|
1746 |
|
1747 if (iError != KErrNone) |
|
1748 { |
|
1749 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
1750 return EInconclusive; |
|
1751 } |
|
1752 |
|
1753 // construct a video picture structure with a valid timestamp and |
|
1754 // write this DevVideoPlay. If the same picture comes back through the |
|
1755 // MdvpoReturnPicture() callback then test has passed. |
|
1756 TVideoPicture picture; |
|
1757 TTimeIntervalMicroSeconds picTime(KTestPictureTimestamp); |
|
1758 picture.iTimestamp = picTime; |
|
1759 picture.iOptions = TVideoPicture::ETimestamp; |
|
1760 |
|
1761 // write picture to DevVideoPlay |
|
1762 TRAP(err, aDevVideoPlay.WritePictureL(&picture) ) |
|
1763 |
|
1764 if (err != expErr) |
|
1765 { |
|
1766 ERR_PRINTF3(_L("WritePicture() gave error %d (expected %d)"),err, expErr); |
|
1767 ret = EFail; |
|
1768 } |
|
1769 else |
|
1770 { |
|
1771 TBool picSuccess = EFalse; |
|
1772 |
|
1773 // check callback has been called and picture is correct |
|
1774 if (iPicture) |
|
1775 { |
|
1776 if ( (iPicture->iTimestamp == picTime) && |
|
1777 (iPicture->iOptions == TVideoPicture::ETimestamp) ) |
|
1778 { |
|
1779 picSuccess = ETrue; |
|
1780 } |
|
1781 } |
|
1782 |
|
1783 if (!picSuccess) |
|
1784 { |
|
1785 ERR_PRINTF1(_L("Received picture is corrupt!")); |
|
1786 ret = EFail; |
|
1787 } |
|
1788 else |
|
1789 { |
|
1790 INFO_PRINTF1(_L("Original picture received correctly")); |
|
1791 INFO_PRINTF3(_L("WritePicture(), %d = %d"), err, expErr); |
|
1792 } |
|
1793 } |
|
1794 |
|
1795 return ret; |
|
1796 } |
|
1797 //------------------------------------------------------------------ |
|
1798 |
|
1799 void CTestDevVideoPlayInputEnd::MdvpoInitComplete(TInt aError) |
|
1800 { |
|
1801 INFO_PRINTF2(_L("CTestDevVideoPlayInputEnd::MdvpoInitComplete(): Error = %d"), aError); |
|
1802 |
|
1803 iError = aError; |
|
1804 } |
|
1805 |
|
1806 void CTestDevVideoPlayInputEnd::MdvpoStreamEnd() |
|
1807 { |
|
1808 INFO_PRINTF1(_L("CTestDevVideoPlayInputEnd::MdvpoStreamEnd()")); |
|
1809 |
|
1810 // keep track on number of times this callback is called |
|
1811 iEndCount++; |
|
1812 } |
|
1813 |
|
1814 CTestDevVideoPlayInputEnd::CTestDevVideoPlayInputEnd(const TDesC& aTestName, TTestType aTestType) |
|
1815 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
1816 { |
|
1817 } |
|
1818 |
|
1819 CTestDevVideoPlayInputEnd* CTestDevVideoPlayInputEnd::NewL(const TDesC& aTestName, TTestType aTestType) |
|
1820 { |
|
1821 CTestDevVideoPlayInputEnd* self = new(ELeave) CTestDevVideoPlayInputEnd(aTestName, aTestType); |
|
1822 return self; |
|
1823 } |
|
1824 |
|
1825 TVerdict CTestDevVideoPlayInputEnd::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
1826 { |
|
1827 TVerdict ret = EPass; |
|
1828 // TInt expErr = KErrNone; |
|
1829 TBool selDec = ETrue; |
|
1830 TBool selPost = ETrue; |
|
1831 |
|
1832 INFO_PRINTF1(_L("CMMFDevVideoPlay: InputEnd")); |
|
1833 |
|
1834 // expected results |
|
1835 switch(iTestType) |
|
1836 { |
|
1837 case ETestValid: |
|
1838 // expErr = KErrNone; // EABI warning removal |
|
1839 break; |
|
1840 case ETestDecoderOnly: |
|
1841 selPost = EFalse; |
|
1842 break; |
|
1843 case ETestPostProcOnly: |
|
1844 selDec = EFalse; |
|
1845 break; |
|
1846 default: |
|
1847 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
1848 return EInconclusive; |
|
1849 } |
|
1850 |
|
1851 TInt err = KErrNone; |
|
1852 |
|
1853 // THwDeviceId hwDecoder = 0; |
|
1854 // THwDeviceId hwPostProc = 0; |
|
1855 |
|
1856 // select decoder |
|
1857 if (selDec) |
|
1858 { |
|
1859 // TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); |
|
1860 TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal |
|
1861 if (err != KErrNone) |
|
1862 { |
|
1863 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
1864 return EInconclusive; |
|
1865 } |
|
1866 } |
|
1867 |
|
1868 // select post-processor |
|
1869 if (selPost) |
|
1870 { |
|
1871 // TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); |
|
1872 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
1873 if (err != KErrNone) |
|
1874 { |
|
1875 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
1876 return EInconclusive; |
|
1877 } |
|
1878 } |
|
1879 // initialize CDevVideoPlay and wait for response |
|
1880 // iError is set by the MdvpoInitComplete callback |
|
1881 aDevVideoPlay.Initialize(); |
|
1882 |
|
1883 if (iError != KErrNone) |
|
1884 { |
|
1885 ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay")); |
|
1886 return EInconclusive; |
|
1887 } |
|
1888 |
|
1889 // call input end on DevVideoPlay and check callback counter == 1 |
|
1890 aDevVideoPlay.InputEnd(); |
|
1891 |
|
1892 if (iEndCount != 1) |
|
1893 { |
|
1894 ERR_PRINTF2(_L("Error - MdvpoStreamEnd only called %d times!"), iEndCount); |
|
1895 ret = EFail; |
|
1896 } |
|
1897 else |
|
1898 INFO_PRINTF1(_L("InputEnd() called successfully")); |
|
1899 |
|
1900 return ret; |
|
1901 } |
|
1902 //------------------------------------------------------------------- |
|
1903 |
|
1904 void CTestDevVideoGetBufferWithoutInitialize::MdvpoInitComplete(TInt aError) |
|
1905 { |
|
1906 INFO_PRINTF2(_L("CTestGetBufferWithoutInitialize::MdvpoInitComplete(): Error = %d"), aError); |
|
1907 |
|
1908 iError = aError; |
|
1909 } |
|
1910 |
|
1911 void CTestDevVideoGetBufferWithoutInitialize::MdvpoNewBuffers() |
|
1912 { |
|
1913 INFO_PRINTF1(_L("CTestGetBufferWithoutInitialize::MdvpoNewBuffers()")); |
|
1914 iCalledBack = ETrue; |
|
1915 } |
|
1916 |
|
1917 CTestDevVideoGetBufferWithoutInitialize::CTestDevVideoGetBufferWithoutInitialize(const TDesC& aTestName, TTestType aTestType) |
|
1918 :CTestDevVideoPlayStep(aTestName, aTestType) |
|
1919 { |
|
1920 } |
|
1921 |
|
1922 CTestDevVideoGetBufferWithoutInitialize* CTestDevVideoGetBufferWithoutInitialize::NewL(const TDesC& aTestName, TTestType aTestType) |
|
1923 { |
|
1924 CTestDevVideoGetBufferWithoutInitialize* self = new(ELeave) CTestDevVideoGetBufferWithoutInitialize(aTestName, aTestType); |
|
1925 return self; |
|
1926 } |
|
1927 |
|
1928 TVerdict CTestDevVideoGetBufferWithoutInitialize::DoTestL(CMMFDevVideoPlay& aDevVideoPlay) |
|
1929 { |
|
1930 TVerdict ret = EPass; |
|
1931 TInt expErr = KErrNone; |
|
1932 |
|
1933 INFO_PRINTF1(_L("CMMFDevVideoPlay: GetBuffer")); |
|
1934 INFO_PRINTF1(_L("To test the scenario wherein GetBufferL is called without calling initialize")); |
|
1935 // expected results |
|
1936 if (iTestType != ETestValid) |
|
1937 { |
|
1938 ERR_PRINTF1(_L("Error - invalid test step type")); |
|
1939 return EInconclusive; |
|
1940 } |
|
1941 |
|
1942 TInt err = KErrNone; |
|
1943 |
|
1944 TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice)); // EABI warning removal |
|
1945 if (err != KErrNone) |
|
1946 { |
|
1947 ERR_PRINTF1(_L("Error - couldn't initialize decoder")); |
|
1948 return EInconclusive; |
|
1949 } |
|
1950 |
|
1951 // select post-processor |
|
1952 TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal |
|
1953 if (err != KErrNone) |
|
1954 { |
|
1955 ERR_PRINTF1(_L("Error - couldn't initialize post processor")); |
|
1956 return EInconclusive; |
|
1957 } |
|
1958 TVideoInputBuffer* newBuff = NULL; |
|
1959 // iError is set by the MdvpoInitComplete callback |
|
1960 TRAP(err, newBuff = aDevVideoPlay.GetBufferL(KTestBufferSize) ); |
|
1961 // callback will occur and newBuff will be set to new buffer |
|
1962 if (err != expErr) |
|
1963 { |
|
1964 ERR_PRINTF3(_L("GetBufferL() gave error %d (expected %d)"),err, expErr); |
|
1965 ret = EFail; |
|
1966 } |
|
1967 else |
|
1968 { |
|
1969 TBool buffSuccess = EFalse; |
|
1970 |
|
1971 // check callback has been called and buffer is correct |
|
1972 if (newBuff && iCalledBack) |
|
1973 { |
|
1974 TTimeIntervalMicroSeconds testTime(KTestBufferSize); |
|
1975 if ( (newBuff->iDecodingTimestamp == testTime) && |
|
1976 (newBuff->iOptions == KTestBufferOptions) && |
|
1977 (newBuff->iData == KTestBufferString) ) |
|
1978 { |
|
1979 buffSuccess = ETrue; |
|
1980 } |
|
1981 } |
|
1982 |
|
1983 if (!buffSuccess) |
|
1984 { |
|
1985 ERR_PRINTF1(_L("Received buffer is corrupt!")); |
|
1986 ret = EFail; |
|
1987 } |
|
1988 else |
|
1989 { |
|
1990 INFO_PRINTF1(_L("Buffer received correctly")); |
|
1991 INFO_PRINTF3(_L("GetBuffer(), %d = %d"), err, expErr); |
|
1992 } |
|
1993 } |
|
1994 |
|
1995 return ret; |
|
1996 } |
|
1997 //----------------------------------------------------------------------- |
|
1998 |