|
1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 #include <mmf/common/mmferrors.h> |
|
17 #include <caf/caf.h> |
|
18 #include "tsu3gplibraryapi.h" |
|
19 |
|
20 using namespace ContentAccess; |
|
21 |
|
22 // -------------------------- |
|
23 // C3GPLibParser_base |
|
24 // -------------------------- |
|
25 // |
|
26 TVerdict C3GPLibParser_base::doTestStepPreambleL() |
|
27 { |
|
28 SetTestStepResult(EPass); |
|
29 SetTestStepError(KErrNone); |
|
30 |
|
31 TPtrC testSection = ConfigSection(); |
|
32 |
|
33 TInt err = iTestSection.Create(testSection.Length()); |
|
34 if( err != KErrNone ) |
|
35 { |
|
36 ERR_PRINTF2(_L("Cannot create buffer for inputFilename. err = %d"), err); |
|
37 SetTestStepResult(EInconclusive); |
|
38 return TestStepResult(); |
|
39 } |
|
40 iTestSection += testSection; |
|
41 |
|
42 TBuf<20> testFolderName; |
|
43 testFolderName.Zero(); |
|
44 if (ConfigSection().Compare(_L("3GP-H264-MP4-LARGE")) == 0) |
|
45 { |
|
46 #ifdef __WINSCW__ |
|
47 testFolderName.Append(_L("inputFileEmu")); |
|
48 #else |
|
49 testFolderName.Append(_L("inputFileHw")); |
|
50 #endif |
|
51 } |
|
52 else |
|
53 { |
|
54 testFolderName.Append(_L("inputFile")); |
|
55 } |
|
56 |
|
57 TPtrC inputFile; |
|
58 if(!GetStringFromConfig(ConfigSection(), testFolderName, inputFile)) |
|
59 { |
|
60 ERR_PRINTF1(_L("Cannot read inputFile from ini file.")); |
|
61 SetTestStepResult(ETestSuiteError); |
|
62 return TestStepResult(); |
|
63 } |
|
64 err = iInputFile.Create(inputFile.Length() + 1); |
|
65 if( err != KErrNone ) |
|
66 { |
|
67 ERR_PRINTF2(_L("Cannot create buffer for inputFilename. err = %d"), err); |
|
68 SetTestStepResult(EInconclusive); |
|
69 return TestStepResult(); |
|
70 } |
|
71 iInputFile += inputFile; |
|
72 iInputFile.ZeroTerminate(); |
|
73 |
|
74 return TestStepResult(); |
|
75 } |
|
76 |
|
77 TVerdict C3GPLibParser_base::doTestStepPostambleL() |
|
78 { |
|
79 iInputFile.Close(); |
|
80 iTestSection.Close(); |
|
81 |
|
82 // Close file |
|
83 iSourceFile.Close(); |
|
84 iSourceFile64.Close(); |
|
85 |
|
86 //Close the file server session |
|
87 iFsSession.Close(); |
|
88 |
|
89 return TestStepResult(); |
|
90 } |
|
91 |
|
92 TInt C3GPLibParser_base::CheckError(TInt aError, TInt aExpectError, const TDesC& aFunction) |
|
93 { |
|
94 if (aError != aExpectError) |
|
95 { |
|
96 ERR_PRINTF4(_L("%S expected %d, but returns %d; "), &aFunction, aExpectError, aError); |
|
97 if (aError != KErrNone) |
|
98 { |
|
99 return aError; |
|
100 } |
|
101 // expected an error, but return KErrNone |
|
102 return KErrGeneral; |
|
103 } |
|
104 return KErrNone; |
|
105 } |
|
106 |
|
107 void C3GPLibParser_base::ParserOpenL(C3GPParse* aParser, TInt aExpectedError) |
|
108 { |
|
109 ASSERT(aParser); |
|
110 |
|
111 TInt err = aParser->Open(); |
|
112 if (aExpectedError == KErrInUse && err == KErrNone) |
|
113 { |
|
114 err = aParser->Open(); |
|
115 } |
|
116 |
|
117 if (ShouldRunOOMTest() && err != KErrNone && err != aExpectedError) |
|
118 { |
|
119 INFO_PRINTF2(_L("Parser open using buffer mode (OOM), returns %d"), err); |
|
120 User::Leave(err); |
|
121 } |
|
122 |
|
123 if (!ShouldRunOOMTest()) |
|
124 { |
|
125 INFO_PRINTF2(_L("Parser open using buffer mode, returns %d"), err); |
|
126 } |
|
127 |
|
128 User::LeaveIfError(CheckError(err, aExpectedError, _L("aParser->Open() buffer mode"))); |
|
129 } |
|
130 |
|
131 void C3GPLibParser_base::ParserOpenFileL(C3GPParse* aParser, TInt aExpectedError) |
|
132 { |
|
133 ASSERT(aParser); |
|
134 |
|
135 TInt err = aParser->Open(iInputFile); |
|
136 if (aExpectedError == KErrInUse && err == KErrNone) |
|
137 { |
|
138 err = aParser->Open(iInputFile); |
|
139 } |
|
140 |
|
141 if (ShouldRunOOMTest() && err != KErrNone && err != aExpectedError) |
|
142 { |
|
143 INFO_PRINTF2(_L("Parser open using file path (OOM), returns %d"), err); |
|
144 User::Leave(err); |
|
145 } |
|
146 |
|
147 if (!ShouldRunOOMTest()) |
|
148 { |
|
149 INFO_PRINTF2(_L("Parser open using file path, returns %d"), err); |
|
150 } |
|
151 |
|
152 User::LeaveIfError(CheckError(err, aExpectedError, _L("aParser->Open() file path"))); |
|
153 } |
|
154 |
|
155 void C3GPLibParser_base::ParserCompleteL(C3GPParse* aParser) |
|
156 { |
|
157 ASSERT(aParser); |
|
158 |
|
159 TInt err = aParser->Complete(); |
|
160 User::LeaveIfError(CheckError(err, KErrNone, _L("aParser->Complete()"))); |
|
161 } |
|
162 |
|
163 void C3GPLibParser_base::FileOpenL(TUint aFileMode) |
|
164 { |
|
165 iSourceFile.Close(); |
|
166 //Create a connection to the file server |
|
167 User::LeaveIfError(iFsSession.Connect()); |
|
168 |
|
169 //Open the source file passing in the file server session handle, source |
|
170 //file path and file access mode |
|
171 User::LeaveIfError(iSourceFile.Open(iFsSession, iInputFile, aFileMode )); |
|
172 } |
|
173 |
|
174 void C3GPLibParser_base::FileClose() |
|
175 { |
|
176 // Close file |
|
177 iSourceFile.Close(); |
|
178 |
|
179 //Close the file server session |
|
180 iFsSession.Close(); |
|
181 } |
|
182 |
|
183 void C3GPLibParser_base::FileOpen64L(TUint aFileMode) |
|
184 { |
|
185 iSourceFile64.Close(); |
|
186 //Create a connection to the file server |
|
187 User::LeaveIfError(iFsSession.Connect()); |
|
188 |
|
189 //Open the source file passing in the file server session handle, source |
|
190 //file path and file access mode |
|
191 User::LeaveIfError(iSourceFile64.Open(iFsSession, iInputFile, aFileMode )); |
|
192 } |
|
193 |
|
194 void C3GPLibParser_base::FileClose64() |
|
195 { |
|
196 // Close file |
|
197 iSourceFile64.Close(); |
|
198 |
|
199 //Close the file server session |
|
200 iFsSession.Close(); |
|
201 } |
|
202 |
|
203 void C3GPLibParser_base::ParserOpenFileHandleL(C3GPParse* aParser, TUint aFileMode, TInt aExpectedError) |
|
204 { |
|
205 ASSERT(aParser); |
|
206 |
|
207 FileOpenL(aFileMode); |
|
208 TInt err = aParser->Open(iSourceFile); |
|
209 if (aExpectedError == KErrInUse && err == KErrNone) |
|
210 { |
|
211 err = aParser->Open(iSourceFile); |
|
212 } |
|
213 |
|
214 if (err != KErrNone && err != aExpectedError) |
|
215 { |
|
216 FileClose(); |
|
217 |
|
218 if (ShouldRunOOMTest()) |
|
219 { |
|
220 INFO_PRINTF2(_L("Parser open using file handle (OOM), returns %d"), err); |
|
221 User::Leave(err); |
|
222 } |
|
223 } |
|
224 |
|
225 if (!ShouldRunOOMTest()) |
|
226 { |
|
227 INFO_PRINTF2(_L("Parser open using file handle, returns %d"), err); |
|
228 } |
|
229 |
|
230 if (err == aExpectedError ) |
|
231 { |
|
232 err = KErrNone; |
|
233 } |
|
234 User::LeaveIfError(err); |
|
235 } |
|
236 |
|
237 void C3GPLibParser_base::ParserCompleteHandleL(C3GPParse* aParser) |
|
238 { |
|
239 ASSERT(aParser); |
|
240 |
|
241 TInt err = aParser->Complete(); |
|
242 if (err != KErrNone) |
|
243 { |
|
244 ERR_PRINTF2(_L("aParser->Complete() file handle failed with %d"), err); |
|
245 } |
|
246 |
|
247 FileClose(); |
|
248 User::LeaveIfError(err); |
|
249 } |
|
250 |
|
251 void C3GPLibParser_base::ParserOpenFileHandle64L(C3GPParse* aParser, TUint aFileMode, TInt aExpectedError) |
|
252 { |
|
253 ASSERT(aParser); |
|
254 |
|
255 FileOpen64L(aFileMode); |
|
256 TInt err = aParser->Open(iSourceFile64); |
|
257 if (aExpectedError == KErrInUse && err == KErrNone) |
|
258 { |
|
259 err = aParser->Open(iSourceFile64); |
|
260 } |
|
261 |
|
262 if (err != KErrNone && err != aExpectedError) |
|
263 { |
|
264 FileClose(); |
|
265 |
|
266 if (ShouldRunOOMTest()) |
|
267 { |
|
268 INFO_PRINTF2(_L("Parser open using 64bit file handle (OOM), returns %d"), err); |
|
269 User::Leave(err); |
|
270 } |
|
271 } |
|
272 |
|
273 if (!ShouldRunOOMTest()) |
|
274 { |
|
275 INFO_PRINTF2(_L("Parser open using 64bit file handle, returns %d"), err); |
|
276 } |
|
277 |
|
278 if (err == aExpectedError ) |
|
279 { |
|
280 err = KErrNone; |
|
281 } |
|
282 User::LeaveIfError(err); |
|
283 } |
|
284 |
|
285 void C3GPLibParser_base::ParserCompleteHandle64L(C3GPParse* aParser) |
|
286 { |
|
287 ASSERT(aParser); |
|
288 |
|
289 TInt err = aParser->Complete(); |
|
290 if (err != KErrNone) |
|
291 { |
|
292 ERR_PRINTF2(_L("aParser->Complete() 64bit file handle failed with %d"), err); |
|
293 } |
|
294 |
|
295 FileClose64(); |
|
296 User::LeaveIfError(err); |
|
297 } |
|
298 |
|
299 void C3GPLibParser_base::ParserOpenCafLC(C3GPParse* aParser, TInt aExpectedError) |
|
300 { |
|
301 ASSERT(aParser); |
|
302 CContent* content = CContent::NewLC(iInputFile, EContentShareReadWrite); |
|
303 CData* data = content->OpenContentL(EPeek); |
|
304 |
|
305 CleanupStack::PushL(data); |
|
306 |
|
307 TInt err = aParser->Open(*data); |
|
308 if (aExpectedError == KErrInUse && err == KErrNone) |
|
309 { |
|
310 err = aParser->Open(*data); |
|
311 } |
|
312 |
|
313 if (ShouldRunOOMTest() && err != KErrNone && err != aExpectedError) |
|
314 { |
|
315 INFO_PRINTF2(_L("Parser open using CAF (OOM), returns %d"), err); |
|
316 User::Leave(err); |
|
317 } |
|
318 |
|
319 if (!ShouldRunOOMTest()) |
|
320 { |
|
321 INFO_PRINTF2(_L("Parser open using CAF, returns %d"), err); |
|
322 } |
|
323 |
|
324 if (err == aExpectedError) |
|
325 { |
|
326 err = KErrNone; |
|
327 } |
|
328 User::LeaveIfError(err); |
|
329 } |
|
330 |
|
331 void C3GPLibParser_base::ParserCompleteCafL(C3GPParse* aParser) |
|
332 { |
|
333 ASSERT(aParser); |
|
334 TInt err = aParser->Complete(); |
|
335 if ( err != KErrNone ) |
|
336 { |
|
337 ERR_PRINTF2(_L("parse->Complete() CAF failed with %d."), err); |
|
338 } |
|
339 |
|
340 CleanupStack::PopAndDestroy(2); // content, data |
|
341 User::LeaveIfError(err); |
|
342 } |
|
343 |
|
344 // Retrieve both video & audio stream properties |
|
345 TInt C3GPLibParser_base::GetClipProperties(C3GPParse* aParse, TInt& aVideoError, TUint& aVideoLength, TUint& aAudioLength) |
|
346 { |
|
347 TInt err = KErrCorrupt; |
|
348 T3GPVideoType videoType; |
|
349 TReal frameRate; |
|
350 TUint avgBitRate; |
|
351 TSize videoSize; |
|
352 TUint timeScale; |
|
353 |
|
354 aVideoError = aParse->GetVideoProperties(videoType, aVideoLength, frameRate, avgBitRate, videoSize, timeScale); |
|
355 |
|
356 if (aVideoError == KErrNone || aVideoError == KErrNotSupported || aVideoError == KErr3gpLibMoreDataRequired) |
|
357 { |
|
358 T3GPAudioType audioType; |
|
359 TInt framesPerSample; |
|
360 err = aParse->GetAudioProperties(audioType, aAudioLength, framesPerSample, avgBitRate, timeScale); |
|
361 } |
|
362 return err; |
|
363 } |
|
364 |
|
365 // Get both audio and video decorder information |
|
366 TInt C3GPLibParser_base::ParserGetDecoderInfo(C3GPParse* aParser) |
|
367 { |
|
368 TInt dsiSize; |
|
369 RBuf8 dsiBuffer; |
|
370 |
|
371 TInt err = aParser->GetAudioDecoderSpecificInfoSize(dsiSize); |
|
372 if ( err == KErrNone ) |
|
373 { |
|
374 err = dsiBuffer.Create(dsiSize); |
|
375 if ( err != KErrNone ) |
|
376 { |
|
377 ERR_PRINTF2(_L("dsiBuffer.Create failed with %d"), err); |
|
378 dsiBuffer.Close(); |
|
379 return err; |
|
380 } |
|
381 |
|
382 err = aParser->GetAudioDecoderSpecificInfo(dsiBuffer); |
|
383 } |
|
384 if ( err != KErrNone ) |
|
385 { |
|
386 if (!ShouldRunOOMTest()) |
|
387 { |
|
388 ERR_PRINTF3(_L("GetAudioDecoderSpecificInfo/Size() failed with %d, size %d"), err, dsiSize); |
|
389 } |
|
390 dsiBuffer.Close(); |
|
391 return err; |
|
392 } |
|
393 |
|
394 err = aParser->GetVideoDecoderSpecificInfoSize(dsiSize); |
|
395 if ( err != KErrNone && err != KErrNotSupported) |
|
396 { |
|
397 dsiBuffer.Close(); |
|
398 ERR_PRINTF2(_L("parse->GetVideoDecoderSpecificInfoSize() failed with %d"), err); |
|
399 return err; |
|
400 } |
|
401 if (err != KErrNotSupported) |
|
402 { |
|
403 dsiBuffer.Close(); |
|
404 err = dsiBuffer.Create(dsiSize); |
|
405 if ( err != KErrNone ) |
|
406 { |
|
407 ERR_PRINTF2(_L("dsiBuffer.Create failed with %d"), err); |
|
408 dsiBuffer.Close(); |
|
409 return err; |
|
410 } |
|
411 |
|
412 err = aParser->GetVideoDecoderSpecificInfo(dsiBuffer); |
|
413 if ( err != KErrNone ) |
|
414 { |
|
415 ERR_PRINTF2(_L("VideoDecoderSpecificInfo() failed with %d"), err); |
|
416 } |
|
417 } |
|
418 dsiBuffer.Close(); |
|
419 return err; |
|
420 } |
|
421 |
|
422 // Read data from file and insert it to the buffer |
|
423 void C3GPLibParser_base::InsertDataL(C3GPParse* aParse, RFile aFile, TInt aBufferSize, TInt aPos) |
|
424 { |
|
425 TInt err = KErrNone; |
|
426 RBuf8 buffer; |
|
427 CleanupClosePushL(buffer); |
|
428 buffer.CreateL(aBufferSize); |
|
429 err = aFile.Read(aPos, buffer); |
|
430 if (err == KErrNone) |
|
431 { |
|
432 err = aParse->InsertData(buffer); |
|
433 if ( err != KErrNone ) |
|
434 { |
|
435 ERR_PRINTF2(_L("parse->InsertData() failed with %d"), err); |
|
436 } |
|
437 } |
|
438 else |
|
439 { |
|
440 ERR_PRINTF2(_L("aFile.Read(aPos, buffer) failed with %d"), err); |
|
441 } |
|
442 buffer.Close(); |
|
443 CleanupStack::PopAndDestroy(&buffer); |
|
444 User::LeaveIfError(err); |
|
445 } |
|
446 |
|
447 // Read audio or video frame(s) depending on the input parameter synchronously |
|
448 TInt C3GPLibParser_base::ReadAudioVideoFrame(C3GPParse* aParse, TBool aRepeat, TBool aReadAudio) |
|
449 { |
|
450 TInt err = KErrNone; |
|
451 // If repeat, read all frames; otherwise, read only one frame |
|
452 while (err == KErrNone) |
|
453 { |
|
454 TUint size; |
|
455 if (aReadAudio) |
|
456 { |
|
457 err = aParse->GetAudioFramesSize(size); |
|
458 } |
|
459 else |
|
460 { |
|
461 err = aParse->GetVideoFrameSize(size); |
|
462 } |
|
463 |
|
464 if (err == KErrNone) |
|
465 { |
|
466 TUint timeStampInMs; |
|
467 TUint timeStampInTimescale; |
|
468 RBuf8 buffer; |
|
469 err = buffer.Create(size); |
|
470 if (err != KErrNone) |
|
471 { |
|
472 ERR_PRINTF2(_L("buffer.Create(size) failed with %d"), err); |
|
473 buffer.Close(); |
|
474 return err; |
|
475 } |
|
476 |
|
477 if (aReadAudio) |
|
478 { |
|
479 TInt returnedFrames; |
|
480 err = aParse->ReadAudioFrames(buffer, returnedFrames, timeStampInMs, timeStampInTimescale); |
|
481 } |
|
482 else |
|
483 { |
|
484 TBool keyframe; |
|
485 err = aParse->ReadVideoFrame(buffer, keyframe, timeStampInMs, timeStampInTimescale); |
|
486 } |
|
487 |
|
488 if (err != KErrNone && err != KErrNotFound && err != KErr3gpLibMoreDataRequired) |
|
489 { |
|
490 if (aReadAudio) |
|
491 { |
|
492 ERR_PRINTF3(_L("parse->GetAudioFrames() failed with %d; frame size: %d"), err, size); |
|
493 } |
|
494 else |
|
495 { |
|
496 ERR_PRINTF3(_L("parse->GetVideoFrame() failed with %d; frame size: %d"), err, size); |
|
497 } |
|
498 buffer.Close(); |
|
499 return err; |
|
500 } |
|
501 buffer.Close(); |
|
502 } |
|
503 |
|
504 if (!aRepeat) |
|
505 { |
|
506 break; |
|
507 } |
|
508 } |
|
509 return err; |
|
510 } |
|
511 |
|
512 // Retrieve user data atom. |
|
513 TInt C3GPLibParser_base::CallUDTApi(C3GPParse* aParse, TUint32 aUdtType, TUint& aIndex, T3GPUdtaLocation aLocation) |
|
514 { |
|
515 TInt err = KErrNone; |
|
516 TInt udtSize; |
|
517 |
|
518 // use a copy of the target index requested by the user, so it does not get overwritten |
|
519 // when calling the APIs GetUserDataAtomSize & GetUserDataAtom |
|
520 TUint tempIndex1 = aIndex; |
|
521 TUint tempIndex2 = aIndex; |
|
522 |
|
523 err = aParse->GetUserDataAtomSize(aUdtType, aLocation, tempIndex1, udtSize); |
|
524 if (err == KErrNone) |
|
525 { |
|
526 RBuf8 buffer; |
|
527 |
|
528 err = buffer.Create(udtSize); // Use size retrieved from GetUserDataAtomSize |
|
529 if (err == KErrNone) |
|
530 { |
|
531 err = aParse->GetUserDataAtom(aUdtType, aLocation, buffer, tempIndex2); |
|
532 if (err == KErrNone && tempIndex1 != tempIndex2) |
|
533 { |
|
534 ERR_PRINTF1(_L("C3GPLibParser_base::CallUDTApi - Highest Index returned is different when calling GetUserDataAtomSize vs GetUserDataAtom")); |
|
535 err = KErrGeneral; |
|
536 } |
|
537 } |
|
538 else |
|
539 { |
|
540 ERR_PRINTF2(_L("buffer.Create(size) failed with %d"), err); |
|
541 } |
|
542 buffer.Close(); |
|
543 } |
|
544 |
|
545 if (err == KErrNone) |
|
546 { |
|
547 // return the highest index found |
|
548 aIndex = tempIndex1; |
|
549 } |
|
550 |
|
551 return err; |
|
552 } |
|
553 |
|
554 void C3GPLibParser_base::DoGetVideoAudioAttributesL(C3GPParse* aParser) |
|
555 { |
|
556 // Retrieve video & audio stream attributes |
|
557 T3GPVideoType videoType; |
|
558 TUint length; |
|
559 TReal frameRate; |
|
560 TUint avgBitRate; |
|
561 TSize videoSize; |
|
562 TUint timeScale; |
|
563 |
|
564 TInt err = aParser->GetVideoProperties(videoType, length, frameRate, avgBitRate, videoSize, timeScale); |
|
565 User::LeaveIfError(CheckError(err, KErrNone, _L("aParser->GetVideoProperties()"))); |
|
566 |
|
567 T3GPAudioType audioType; |
|
568 TInt framesPerSample; |
|
569 err = aParser->GetAudioProperties(audioType, length, framesPerSample, avgBitRate, timeScale); |
|
570 User::LeaveIfError(CheckError(err, KErrNone, _L("aParser->GetAudioProperties()"))); |
|
571 |
|
572 err = ParserGetDecoderInfo(aParser); |
|
573 User::LeaveIfError(CheckError(err, KErrNone, _L("ParserGetDecoderInfo(aParser)"))); |
|
574 |
|
575 TUint numVideoFrames; |
|
576 err = aParser->GetNumberOfVideoFrames(numVideoFrames); |
|
577 User::LeaveIfError(CheckError(err, KErrNone, _L("parse->GetNumberOfVideoFrames"))); |
|
578 |
|
579 TUint startIndex = 0; |
|
580 RArray<T3GPFrameInfoParameters> array; |
|
581 err = aParser->GetVideoFrameProperties(startIndex, numVideoFrames, array); |
|
582 array.Close(); |
|
583 User::LeaveIfError(CheckError(err, KErrNone, _L("parse->GetVideoFrameProperties"))); |
|
584 } |
|
585 |
|
586 TInt C3GPLibParser_base::DoReadFrame(C3GPParse* aParse) |
|
587 { |
|
588 TInt numBufferedBytes; |
|
589 TInt err = aParse->GetNumBufferedBytes(numBufferedBytes); |
|
590 if (err != KErrNone && numBufferedBytes != 0) |
|
591 { |
|
592 // when GetNumBufferedBytes returns error, numBufferedBytes is set to zero. |
|
593 return err; |
|
594 } |
|
595 err = CheckError(err, KErrNotSupported, _L("parse->GetNumBufferedBytes()")); |
|
596 if (err == KErrNone) |
|
597 { |
|
598 // read audio frame |
|
599 err = ReadAudioVideoFrame(aParse, ETrue, ETrue); |
|
600 // When finishing reading all frames, it returns KErrNotFound |
|
601 err = CheckError(err, KErrNotFound, _L("ReadAudioVideoFrame(aParse, ETrue)")); |
|
602 |
|
603 if (err == KErrNone) |
|
604 { |
|
605 // read video frame |
|
606 err = ReadAudioVideoFrame(aParse, ETrue, EFalse); |
|
607 // When finishing reading all frames, it returns KErrNotFound |
|
608 err = CheckError(err, KErrNotFound, _L("ReadAudioVideoFrame(aParse, EFalse)")); |
|
609 } |
|
610 |
|
611 // After finishing reading all frame, the next video time stamp should return with KErrEof |
|
612 TUint timeStampInMs; |
|
613 TUint timeStampInTimescale; |
|
614 err = aParse->GetVideoTimestamp(timeStampInMs, timeStampInTimescale); |
|
615 err = CheckError(err, KErrEof, _L("GetVideoTimestamp()")); |
|
616 } |
|
617 |
|
618 return err; |
|
619 } |
|
620 |
|
621 void C3GPLibParser_base::DoSeekTestL(C3GPParse* aParser) |
|
622 { |
|
623 // testclip_h263_qcif_15fps_armnb_8khz_onlyvideo.3GP with some key frame |
|
624 TUint num; |
|
625 TUint audioPos; |
|
626 TUint videoPos; |
|
627 TUint timeStampInMs = 0; // for key frame |
|
628 TUint timeStampInTimescale = 0; // for key frame |
|
629 TUint timeStampInMs1 = 0; // for non key frame immediately after key frame |
|
630 TUint timeStampInTimescale1 = 0; // for non-key frame immediately after key frame |
|
631 TUint keyFrameIndex = 0; |
|
632 TBool keyFrame; |
|
633 TInt err = aParser->GetNumberOfVideoFrames(num); |
|
634 if (err == KErrNone) |
|
635 { |
|
636 for (TInt i = 0; i < num; i++) |
|
637 { |
|
638 err = aParser->GetVideoFrameKeyType(i, keyFrame); |
|
639 if (err == KErrNone && keyFrame) |
|
640 { |
|
641 keyFrameIndex = i; |
|
642 err = aParser->GetVideoFrameStartTime(keyFrameIndex, timeStampInMs, timeStampInTimescale); |
|
643 } |
|
644 if (err == KErrNone && !keyFrame && keyFrameIndex > 0) |
|
645 { |
|
646 keyFrameIndex = i; |
|
647 err = aParser->GetVideoFrameStartTime(keyFrameIndex, timeStampInMs1, timeStampInTimescale1); |
|
648 break; |
|
649 } |
|
650 if (err != KErrNone) |
|
651 { |
|
652 ERR_PRINTF3(_L("aParser->GetVideoFrameKeyType() failed with %d at i %d"), err, i); |
|
653 User::Leave(err); |
|
654 } |
|
655 } |
|
656 } |
|
657 else |
|
658 { |
|
659 ERR_PRINTF2(_L("aParser->GetNumberOfVideoFrames() failed with %d"), err); |
|
660 User::Leave(err); |
|
661 } |
|
662 err = aParser->Seek(timeStampInMs, ETrue, audioPos, videoPos); |
|
663 if (err != KErrNone || timeStampInMs != videoPos) |
|
664 { |
|
665 ERR_PRINTF4(_L("aParser->Seek() return %d, timeStampInMs %d, videoPos %d"), err, timeStampInMs, videoPos); |
|
666 } |
|
667 if (err == KErrNone && timeStampInMs != videoPos) |
|
668 { |
|
669 User::LeaveIfError(KErrGeneral); |
|
670 } |
|
671 User::LeaveIfError(err); |
|
672 |
|
673 err = aParser->Seek(timeStampInMs1, EFalse, audioPos, videoPos); |
|
674 if (err != KErrNone || timeStampInMs1 != videoPos) |
|
675 { |
|
676 ERR_PRINTF4(_L("aParser->Seek() return %d, timeStampInMs1 %d, videoPos %d"), err, timeStampInMs1, videoPos); |
|
677 } |
|
678 if (err == KErrNone && timeStampInMs1 != videoPos) |
|
679 { |
|
680 User::LeaveIfError(KErrGeneral); |
|
681 } |
|
682 User::LeaveIfError(err); |
|
683 } |
|
684 |
|
685 void C3GPLibParser_base::ReadFrameBufferModeL(C3GPParse* aParser) |
|
686 { |
|
687 ParserOpenL(aParser); |
|
688 |
|
689 TInt errReadAudio = KErrNone; |
|
690 TInt errReadVideo = KErrNone; |
|
691 // Insert 1K data into the library |
|
692 TInt pos = 0; |
|
693 TInt bufferSize = 1000; |
|
694 |
|
695 InsertDataL(aParser, iSourceFile, bufferSize, pos); |
|
696 errReadAudio = ReadAudioVideoFrame(aParser, ETrue, ETrue); |
|
697 errReadVideo = ReadAudioVideoFrame(aParser, ETrue, EFalse); |
|
698 |
|
699 while (errReadAudio == KErr3gpLibMoreDataRequired || errReadVideo == KErr3gpLibMoreDataRequired) |
|
700 { |
|
701 pos = pos + bufferSize; |
|
702 InsertDataL(aParser, iSourceFile, bufferSize, pos); |
|
703 if (errReadAudio == KErr3gpLibMoreDataRequired) |
|
704 { |
|
705 errReadAudio = ReadAudioVideoFrame(aParser, ETrue, ETrue); |
|
706 } |
|
707 |
|
708 if (errReadVideo == KErr3gpLibMoreDataRequired) |
|
709 { |
|
710 errReadVideo = ReadAudioVideoFrame(aParser, ETrue, EFalse); |
|
711 } |
|
712 } |
|
713 |
|
714 // When last frame has been read, it should return KErrNotFound |
|
715 if (errReadAudio != KErrNotFound) |
|
716 { |
|
717 ERR_PRINTF1(_L("parse->ReadAudioFrames() expects KErrNotFound. ")); |
|
718 User::Leave(errReadAudio); |
|
719 } |
|
720 if (errReadVideo != KErrNotFound) |
|
721 { |
|
722 ERR_PRINTF1(_L("parse->ReadVideoFrame expects KErrNotFound. ")); |
|
723 User::Leave(errReadVideo); |
|
724 } |
|
725 |
|
726 ParserCompleteL(aParser); |
|
727 } |
|
728 |
|
729 C3GPLib_AsyncObserver::C3GPLib_AsyncObserver() |
|
730 { |
|
731 } |
|
732 |
|
733 TVerdict C3GPLib_AsyncObserver::doTestStepPreambleL() |
|
734 { |
|
735 C3GPLibParser_base::doTestStepPreambleL(); |
|
736 |
|
737 iSchedulerWait = new (ELeave) CActiveSchedulerWait; |
|
738 if(!iSchedulerWait) |
|
739 { |
|
740 SetTestStepResult(EInconclusive); |
|
741 } |
|
742 return TestStepResult(); |
|
743 } |
|
744 |
|
745 // ----------------------------------------------------------------------------- |
|
746 // C3GPLib_AsyncObserver for asynchronous read |
|
747 // ----------------------------------------------------------------------------- |
|
748 // |
|
749 TVerdict C3GPLib_AsyncObserver::doTestStepPostambleL() |
|
750 { |
|
751 C3GPLibParser_base::doTestStepPostambleL(); |
|
752 if ( iSchedulerWait) |
|
753 { |
|
754 if (iSchedulerWait->IsStarted()) |
|
755 { |
|
756 iSchedulerWait->AsyncStop(); |
|
757 } |
|
758 delete iSchedulerWait; |
|
759 iSchedulerWait = NULL; |
|
760 } |
|
761 return TestStepResult(); |
|
762 } |
|
763 |
|
764 // Read audio or video frame(s) depending on the input parameter asynchronously |
|
765 TInt C3GPLib_AsyncObserver::ReadAudioVideoFrameAsync(C3GPParse* aParse, TBool aReadAudio, TBool aCancel) |
|
766 { |
|
767 TInt err = KErrNone; |
|
768 TUint size; |
|
769 |
|
770 while (err == KErrNone) |
|
771 { |
|
772 if (aReadAudio) |
|
773 { |
|
774 err = aParse->GetAudioFramesSize(size); |
|
775 } |
|
776 else |
|
777 { |
|
778 err = aParse->GetVideoFrameSize(size); |
|
779 } |
|
780 |
|
781 RBuf8 buffer; |
|
782 if (err == KErrNone) |
|
783 { |
|
784 err = buffer.Create(size); |
|
785 } |
|
786 else |
|
787 { |
|
788 err = buffer.Create(KBufferSize); |
|
789 } |
|
790 |
|
791 if (err != KErrNone) |
|
792 { |
|
793 ERR_PRINTF2(_L("buffer.Create(KBufferSize) failed with %d"), err); |
|
794 buffer.Close(); |
|
795 return err; |
|
796 } |
|
797 |
|
798 iWaitForNotification = ETrue; |
|
799 if (aReadAudio) |
|
800 { |
|
801 aParse->ReadAudioFrames(*this, buffer); |
|
802 } |
|
803 else |
|
804 { |
|
805 aParse->ReadVideoFrame(*this, buffer); |
|
806 } |
|
807 |
|
808 if (aCancel && iAsyncError == KErrNone) |
|
809 { |
|
810 aParse->CancelReadFrame(); |
|
811 // Calling cancel again won't have effects |
|
812 aParse->CancelReadFrame(); |
|
813 |
|
814 // Do read frame again |
|
815 if (aReadAudio) |
|
816 { |
|
817 aParse->ReadAudioFrames(*this, buffer); |
|
818 } |
|
819 else |
|
820 { |
|
821 aParse->ReadVideoFrame(*this, buffer); |
|
822 } |
|
823 } |
|
824 |
|
825 if (iWaitForNotification) |
|
826 { |
|
827 iSchedulerWait->Start(); |
|
828 } |
|
829 |
|
830 err = iAsyncError; |
|
831 buffer.Close(); |
|
832 } |
|
833 |
|
834 if ( iSchedulerWait->IsStarted() ) |
|
835 { |
|
836 iSchedulerWait->AsyncStop(); |
|
837 } |
|
838 |
|
839 if (err != KErrNone && err != KErrNotFound) |
|
840 { |
|
841 if (!ShouldRunOOMTest()) |
|
842 { |
|
843 ERR_PRINTF2(_L("ReadAudioVideoFrameAsync failed with %d;"), err); |
|
844 } |
|
845 } |
|
846 else |
|
847 { |
|
848 err = KErrNone; |
|
849 } |
|
850 |
|
851 return err; |
|
852 } |
|
853 |
|
854 void C3GPLib_AsyncObserver::AudioFramesAvailable(TInt aError, TUint aReturnedFrames, |
|
855 TUint aTimeStampInMs, TUint aTimeStampInTimescale) |
|
856 { |
|
857 iWaitForNotification = EFalse; |
|
858 iAsyncLastNotificationFromAudio = EFalse; |
|
859 iAsyncError = aError; |
|
860 iAsyncAudioTimeStampInMs = aTimeStampInMs; |
|
861 iAsyncAudioReturnedFrames = aReturnedFrames; |
|
862 iAsyncAudioTimestampInTimescale = aTimeStampInTimescale; |
|
863 if (iSchedulerWait->IsStarted()) |
|
864 { |
|
865 iSchedulerWait->AsyncStop(); |
|
866 } |
|
867 |
|
868 } |
|
869 |
|
870 void C3GPLib_AsyncObserver::VideoFrameAvailable(TInt aError, TBool aKeyFrame, TUint |
|
871 aTimeStampInMs, TUint aTimeStampInTimescale) |
|
872 { |
|
873 iWaitForNotification = EFalse; |
|
874 iAsyncLastNotificationFromAudio = EFalse; |
|
875 iAsyncError = aError; |
|
876 iAsyncVideoTimeStampInMs = aTimeStampInMs; |
|
877 iAsyncVideoKeyFrame = aKeyFrame; |
|
878 iAsyncVideoTimestampInTimescale = aTimeStampInTimescale; |
|
879 |
|
880 if (iSchedulerWait->IsStarted()) |
|
881 { |
|
882 iSchedulerWait->AsyncStop(); |
|
883 } |
|
884 |
|
885 } |
|
886 |
|
887 |
|
888 |
|
889 // ----------------------------------------------------------------------------- |
|
890 // Setup parser to read file by file path. |
|
891 // ----------------------------------------------------------------------------- |
|
892 // |
|
893 C3GPLibParser_0001::C3GPLibParser_0001() |
|
894 { |
|
895 } |
|
896 |
|
897 TVerdict C3GPLibParser_0001::doTestStepL() |
|
898 { |
|
899 if(TestStepResult() == EPass) |
|
900 { |
|
901 C3GPParse* parser = C3GPParse::NewL(); |
|
902 CleanupStack::PushL(parser); |
|
903 |
|
904 OpenCompleteL(parser); |
|
905 |
|
906 CleanupStack::PopAndDestroy(parser); |
|
907 } |
|
908 return TestStepResult(); |
|
909 } |
|
910 |
|
911 void C3GPLibParser_0001::OpenCompleteL(C3GPParse* aParser) |
|
912 { |
|
913 // Test open and complete with default file access mode |
|
914 ParserOpenFileL(aParser); |
|
915 ParserCompleteL(aParser); |
|
916 |
|
917 FileOpenL(); |
|
918 ParserOpenFileL(aParser); |
|
919 ParserCompleteL(aParser); |
|
920 ParserCompleteL(aParser); // Should not fail when calling complete twice |
|
921 FileClose(); |
|
922 |
|
923 //Open the source file passing in the file server session handle, source |
|
924 //file path and file access mode (read-write) |
|
925 FileOpenL(EFileShareReadersOrWriters | EFileWrite); |
|
926 ParserOpenFileL(aParser); |
|
927 ParserCompleteL(aParser); |
|
928 ParserCompleteL(aParser); |
|
929 FileClose(); |
|
930 |
|
931 //Open the source file passing in the file server session handle, source |
|
932 //file path and file access mode (read-write) |
|
933 FileOpenL(EFileShareReadersOrWriters | EFileRead); |
|
934 ParserOpenFileL(aParser); |
|
935 ParserCompleteL(aParser); |
|
936 FileClose(); |
|
937 |
|
938 //Open the source file passing in the file server session handle, source |
|
939 //file path and file access mode (read-write) |
|
940 FileOpenL(EFileShareAny | EFileWrite); |
|
941 ParserOpenFileL(aParser); |
|
942 ParserCompleteL(aParser); |
|
943 FileClose(); |
|
944 |
|
945 //Open the source file passing in the file server session handle, source |
|
946 //file path and file access mode (read-write) |
|
947 FileOpenL(EFileShareAny | EFileRead); |
|
948 ParserOpenFileL(aParser); |
|
949 ParserCompleteL(aParser); |
|
950 FileClose(); |
|
951 } |
|
952 |
|
953 // ----------------------------------------------------------------------------- |
|
954 // Setup parser to read file by buffer mode. |
|
955 // ----------------------------------------------------------------------------- |
|
956 // |
|
957 C3GPLibParser_0002::C3GPLibParser_0002() |
|
958 { |
|
959 } |
|
960 |
|
961 TVerdict C3GPLibParser_0002::doTestStepL() |
|
962 { |
|
963 if(TestStepResult() == EPass) |
|
964 { |
|
965 C3GPParse* parser = C3GPParse::NewL(); |
|
966 CleanupStack::PushL(parser); |
|
967 |
|
968 OpenCompleteBufferModeL(parser); |
|
969 |
|
970 CleanupStack::PopAndDestroy(parser); |
|
971 } |
|
972 return TestStepResult(); |
|
973 } |
|
974 |
|
975 void C3GPLibParser_0002::OpenCompleteBufferModeL(C3GPParse* aParser) |
|
976 { |
|
977 // buffer mode |
|
978 FileOpenL(); |
|
979 ParserOpenL(aParser); |
|
980 |
|
981 ParserCompleteL(aParser); |
|
982 FileClose(); |
|
983 } |
|
984 |
|
985 // ----------------------------------------------------------------------------- |
|
986 // Setup parser to read file by file handle. |
|
987 // ----------------------------------------------------------------------------- |
|
988 // |
|
989 C3GPLibParser_0003::C3GPLibParser_0003() |
|
990 { |
|
991 } |
|
992 |
|
993 TVerdict C3GPLibParser_0003::doTestStepL() |
|
994 { |
|
995 if(TestStepResult() == EPass) |
|
996 { |
|
997 C3GPParse* parser = C3GPParse::NewL(); |
|
998 CleanupStack::PushL(parser); |
|
999 |
|
1000 OpenCompleteFileHandleL(parser); |
|
1001 |
|
1002 CleanupStack::PopAndDestroy(parser); |
|
1003 } |
|
1004 return TestStepResult(); |
|
1005 } |
|
1006 |
|
1007 void C3GPLibParser_0003::OpenCompleteFileHandleL(C3GPParse* aParser) |
|
1008 { |
|
1009 ParserOpenFileHandleL(aParser); |
|
1010 ParserCompleteHandleL(aParser); |
|
1011 |
|
1012 //Open the source file passing in the file server session handle, source |
|
1013 //file path and file access mode (read-only) |
|
1014 ParserOpenFileHandleL(aParser, EFileRead | EFileShareReadersOnly); |
|
1015 ParserCompleteHandleL(aParser); |
|
1016 |
|
1017 //Open the source file passing in the file server session handle, source |
|
1018 //file path and file access mode (read-only) |
|
1019 ParserOpenFileHandleL(aParser, EFileShareReadersOrWriters | EFileWrite); |
|
1020 ParserCompleteHandleL(aParser); |
|
1021 |
|
1022 //Open the source file passing in the file server session handle, source |
|
1023 //file path and file access mode (read-only) |
|
1024 ParserOpenFileHandleL(aParser, EFileShareReadersOrWriters | EFileRead); |
|
1025 ParserCompleteHandleL(aParser); |
|
1026 |
|
1027 //Open the source file passing in the file server session handle, source |
|
1028 //file path and file access mode (read-only) |
|
1029 ParserOpenFileHandleL(aParser, EFileShareAny | EFileWrite); |
|
1030 ParserCompleteHandleL(aParser); |
|
1031 |
|
1032 //Open the source file passing in the file server session handle, source |
|
1033 //file path and file access mode (read-only) |
|
1034 ParserOpenFileHandleL(aParser, EFileShareAny | EFileRead); |
|
1035 ParserCompleteHandleL(aParser); |
|
1036 } |
|
1037 |
|
1038 // ----------------------------------------------------------------------------- |
|
1039 // Setup parser to read file by CAF. |
|
1040 // ----------------------------------------------------------------------------- |
|
1041 // |
|
1042 C3GPLibParser_0004::C3GPLibParser_0004() |
|
1043 { |
|
1044 } |
|
1045 |
|
1046 TVerdict C3GPLibParser_0004::doTestStepL() |
|
1047 { |
|
1048 if(TestStepResult() == EPass) |
|
1049 { |
|
1050 CContent* content = CContent::NewLC(iInputFile, EContentShareReadWrite); |
|
1051 |
|
1052 CData* data = content->OpenContentL(EPeek); |
|
1053 CleanupStack::PushL(data); |
|
1054 |
|
1055 C3GPParse* parser = C3GPParse::NewL(); |
|
1056 CleanupStack::PushL(parser); |
|
1057 |
|
1058 TInt err = parser->Open(*data); |
|
1059 |
|
1060 if (err != KErrNone) |
|
1061 { |
|
1062 SetTestStepResult(EFail); |
|
1063 CleanupStack::PopAndDestroy(parser); |
|
1064 CleanupStack::PopAndDestroy(2); // content, data |
|
1065 return TestStepResult(); |
|
1066 } |
|
1067 |
|
1068 err = parser->Complete(); |
|
1069 if (err != KErrNone) |
|
1070 { |
|
1071 SetTestStepResult(EFail); |
|
1072 } |
|
1073 |
|
1074 CleanupStack::PopAndDestroy(parser); |
|
1075 CleanupStack::PopAndDestroy(2); // content, data |
|
1076 } |
|
1077 return TestStepResult(); |
|
1078 } |
|
1079 |
|
1080 // ----------------------------------------------------------------------------- |
|
1081 // Retrieve video & audio stream attributes from a mp4/3gp/3g2 file with supported |
|
1082 // video and audio streams using file mode - file path / file handle and CAF object. |
|
1083 // ----------------------------------------------------------------------------- |
|
1084 // |
|
1085 C3GPLibParser_0005::C3GPLibParser_0005() |
|
1086 { |
|
1087 } |
|
1088 |
|
1089 TVerdict C3GPLibParser_0005::doTestStepL() |
|
1090 { |
|
1091 if(TestStepResult() == EPass) |
|
1092 { |
|
1093 C3GPParse* parser = C3GPParse::NewL(); |
|
1094 CleanupStack::PushL(parser); |
|
1095 |
|
1096 TRAPD(err, GetVideoAudioAttributesL(parser)); |
|
1097 if (err != KErrNone) |
|
1098 { |
|
1099 SetTestStepResult(EFail); |
|
1100 } |
|
1101 |
|
1102 CleanupStack::PopAndDestroy(parser); |
|
1103 } |
|
1104 return TestStepResult(); |
|
1105 } |
|
1106 |
|
1107 void C3GPLibParser_0005::GetVideoAudioAttributesL(C3GPParse* aParser) |
|
1108 { |
|
1109 // Open parser in File path |
|
1110 ParserOpenFileL(aParser); |
|
1111 DoGetVideoAudioAttributesL(aParser); |
|
1112 ParserCompleteL(aParser); |
|
1113 |
|
1114 // open parser in file handle |
|
1115 ParserOpenFileHandleL(aParser); |
|
1116 DoGetVideoAudioAttributesL(aParser); |
|
1117 ParserCompleteHandleL(aParser); |
|
1118 |
|
1119 // Open parser in CAF |
|
1120 ParserOpenCafLC(aParser); |
|
1121 DoGetVideoAudioAttributesL(aParser); |
|
1122 ParserCompleteCafL(aParser); |
|
1123 } |
|
1124 |
|
1125 // ----------------------------------------------------------------------------- |
|
1126 // Retrieve video & audio stream attributes from a mp4/3gp/3g2 file |
|
1127 // with supported video and audio streams using buffer mode. |
|
1128 // ----------------------------------------------------------------------------- |
|
1129 // |
|
1130 C3GPLibParser_0006::C3GPLibParser_0006() |
|
1131 { |
|
1132 } |
|
1133 |
|
1134 TVerdict C3GPLibParser_0006::doTestStepL() |
|
1135 { |
|
1136 if(TestStepResult() == EPass) |
|
1137 { |
|
1138 C3GPParse* parser = C3GPParse::NewL(); |
|
1139 CleanupStack::PushL(parser); |
|
1140 |
|
1141 TRAPD(err, VideoAudioAttributesBufferModeL(parser)); |
|
1142 if (err != KErrNone) |
|
1143 { |
|
1144 SetTestStepResult(EFail); |
|
1145 FileClose(); |
|
1146 } |
|
1147 |
|
1148 CleanupStack::PopAndDestroy(parser); |
|
1149 } |
|
1150 return TestStepResult(); |
|
1151 } |
|
1152 |
|
1153 void C3GPLibParser_0006::VideoAudioAttributesBufferModeL(C3GPParse* aParser) |
|
1154 { |
|
1155 // buffer mode |
|
1156 FileOpenL(); |
|
1157 ParserOpenL(aParser); |
|
1158 |
|
1159 TInt err = KErrNone; |
|
1160 // Retrieve number of buffered bytes before and after data is supplied to the parser. |
|
1161 err = GetVideoAudioAttributes(aParser, ENumBufferedBytes); |
|
1162 User::LeaveIfError(CheckError(err, KErrNone, _L("GetVideoAudioAttributes(aParser, ENumBufferedBytes)"))); |
|
1163 |
|
1164 ParserCompleteL(aParser); |
|
1165 FileClose(); |
|
1166 |
|
1167 // Open the parser again |
|
1168 FileOpenL(); |
|
1169 ParserOpenL(aParser); |
|
1170 |
|
1171 // Retrieve video and audio descriptions before and after data is supplied to the parser. |
|
1172 err = GetVideoAudioAttributes(aParser, EClipProperties); |
|
1173 User::LeaveIfError(CheckError(err, KErrNone, _L("GetVideoAudioAttributes(aParser, EClipProperties)"))); |
|
1174 |
|
1175 ParserCompleteL(aParser); |
|
1176 FileClose(); |
|
1177 |
|
1178 // Open the parser again |
|
1179 FileOpenL(); |
|
1180 ParserOpenL(aParser); |
|
1181 |
|
1182 // Retrieve video and audio decoder before and after data is supplied to the parser. |
|
1183 err = GetVideoAudioAttributes(aParser, EDecoderInfo); |
|
1184 User::LeaveIfError(CheckError(err, KErrNone, _L("GetVideoAudioAttributes(aParser, EDecoderInfo)"))); |
|
1185 |
|
1186 ParserCompleteL(aParser); |
|
1187 FileClose(); |
|
1188 |
|
1189 // Open the parser again |
|
1190 FileOpenL(); |
|
1191 ParserOpenL(aParser); |
|
1192 |
|
1193 |
|
1194 // Retrieve video frame properties and number of frames before and after data is supplied to the parser. |
|
1195 |
|
1196 err = GetVideoAudioAttributes(aParser, EVideoFrameProp); |
|
1197 User::LeaveIfError(CheckError(err, KErrNone, _L("GetVideoAudioAttributes(aParser, EVideoFrameProp)"))); |
|
1198 |
|
1199 ParserCompleteL(aParser); |
|
1200 FileClose(); |
|
1201 } |
|
1202 |
|
1203 TInt C3GPLibParser_0006::CallTest(C3GPParse* aParser, TBufferModeTest aTest, TInt aExpectedNumBuffered) |
|
1204 { |
|
1205 TInt err = KErrNone; |
|
1206 TInt numBufferedBytes; |
|
1207 |
|
1208 // Before insert any data. Retrieving video and audio attributes should fail |
|
1209 switch (aTest) |
|
1210 { |
|
1211 case (ENumBufferedBytes): |
|
1212 err = aParser->GetNumBufferedBytes(numBufferedBytes); |
|
1213 if (err == KErrNone && numBufferedBytes != aExpectedNumBuffered) |
|
1214 { |
|
1215 err = KErrGeneral; |
|
1216 } |
|
1217 break; |
|
1218 case (EClipProperties): |
|
1219 TInt videoError; |
|
1220 TUint videoLength; |
|
1221 TUint audioLength; |
|
1222 err = GetClipProperties(aParser, videoError, videoLength, audioLength); |
|
1223 if ((videoError != KErrNone && videoError != KErr3gpLibMoreDataRequired) || |
|
1224 (err != KErrNone && err != KErr3gpLibMoreDataRequired)) |
|
1225 { |
|
1226 err = KErrGeneral; |
|
1227 } |
|
1228 break; |
|
1229 case (EDecoderInfo): |
|
1230 err = ParserGetDecoderInfo(aParser); |
|
1231 break; |
|
1232 case (EVideoFrameProp): |
|
1233 if (aExpectedNumBuffered == 0) |
|
1234 { |
|
1235 err = GetVideoFramePropAndNumVideoFrame(aParser, EFalse); |
|
1236 } |
|
1237 else |
|
1238 { |
|
1239 err = GetVideoFramePropAndNumVideoFrame(aParser, ETrue); |
|
1240 } |
|
1241 break; |
|
1242 default: |
|
1243 break; |
|
1244 } |
|
1245 return err; |
|
1246 } |
|
1247 |
|
1248 TInt C3GPLibParser_0006::GetVideoAudioAttributes(C3GPParse* aParser, TBufferModeTest aTest) |
|
1249 { |
|
1250 TInt err = KErrNone; |
|
1251 |
|
1252 // Before insert any data. Retrieving video and audio attributes should fail |
|
1253 err = CallTest(aParser, aTest, 0); |
|
1254 if (aTest != ENumBufferedBytes) |
|
1255 { |
|
1256 err = CheckError(err, KErr3gpLibMoreDataRequired, _L("CallTest(aParser, aTest, 0)")); |
|
1257 } |
|
1258 else |
|
1259 { |
|
1260 err = CheckError(err, KErrNone, _L("CallTest()")); |
|
1261 } |
|
1262 |
|
1263 if (err != KErrNone) |
|
1264 { |
|
1265 ERR_PRINTF2(_L("GetVideoAudioAttributes failed with %d; "), err); |
|
1266 return KErrGeneral; |
|
1267 } |
|
1268 |
|
1269 // Insert 1K data to buffer |
|
1270 TInt bufferSize = 0; |
|
1271 TInt pos = 0; // from begining of the file |
|
1272 err = KErr3gpLibMoreDataRequired; |
|
1273 // Insert data until enough data has been inserted |
|
1274 while (err == KErr3gpLibMoreDataRequired) |
|
1275 { |
|
1276 // Insert more data to buffer |
|
1277 pos = bufferSize + pos; |
|
1278 bufferSize = KBufferSize; |
|
1279 RBuf8 buffer; |
|
1280 err = buffer.Create(bufferSize); |
|
1281 if (err == KErrNone) |
|
1282 { |
|
1283 err = iSourceFile.Read(pos, buffer); |
|
1284 if (err == KErrNone) |
|
1285 { |
|
1286 err = aParser->InsertData(buffer); |
|
1287 if ( err == KErrNone ) |
|
1288 { |
|
1289 err = CallTest(aParser, aTest, (bufferSize + pos)); |
|
1290 } |
|
1291 } |
|
1292 } |
|
1293 buffer.Close(); |
|
1294 } |
|
1295 |
|
1296 err = CheckError(err, KErrNone, _L("CallTest()")); |
|
1297 return err; |
|
1298 } |
|
1299 |
|
1300 TInt C3GPLibParser_0006::GetVideoFramePropAndNumVideoFrame(C3GPParse* aParse, TBool aExpectPass) |
|
1301 { |
|
1302 TInt err = KErrNone; |
|
1303 TUint numVideoFrames; |
|
1304 err = aParse->GetNumberOfVideoFrames(numVideoFrames); |
|
1305 if (aExpectPass) |
|
1306 { |
|
1307 if ( err == KErrNone ) |
|
1308 { |
|
1309 // Only when GetNumberOfVideoFrames returns KErrNone, the method GetVideoFrameProperties |
|
1310 // can be called |
|
1311 TUint startIndex = 0; |
|
1312 RArray<T3GPFrameInfoParameters> array; |
|
1313 err = aParse->GetVideoFrameProperties(startIndex, numVideoFrames, array); |
|
1314 array.Close(); |
|
1315 } |
|
1316 } |
|
1317 else |
|
1318 { |
|
1319 // When there is no data in the handler, GetNumberOfVideoFrames will fail with KErrGeneral, |
|
1320 // not the KErr3gpLibMoreDataRequired |
|
1321 if ( err == KErr3gpLibMoreDataRequired || err == KErrGeneral) |
|
1322 { |
|
1323 if (!ShouldRunOOMTest()) |
|
1324 { |
|
1325 INFO_PRINTF2(_L("Expect parse->GetNumberOfVideoFrames() failed with %d"), err); |
|
1326 } |
|
1327 err = KErr3gpLibMoreDataRequired; |
|
1328 } |
|
1329 // expected failure, but get KErrNone. |
|
1330 if (err == KErrNone) |
|
1331 { |
|
1332 INFO_PRINTF1(_L("parse->GetNumberOfVideoFrames() should fail due to buffer too small")); |
|
1333 err = KErrGeneral; |
|
1334 } |
|
1335 } |
|
1336 |
|
1337 return err; |
|
1338 } |
|
1339 |
|
1340 // ----------------------------------------------------------------------------- |
|
1341 // Check if the clip is streamable in file mode from a mp4/3gp/3g2 file |
|
1342 // ----------------------------------------------------------------------------- |
|
1343 // |
|
1344 C3GPLibParser_0007::C3GPLibParser_0007() |
|
1345 { |
|
1346 } |
|
1347 |
|
1348 TVerdict C3GPLibParser_0007::doTestStepL() |
|
1349 { |
|
1350 if(TestStepResult() == EPass) |
|
1351 { |
|
1352 C3GPParse* parser = C3GPParse::NewL(); |
|
1353 CleanupStack::PushL(parser); |
|
1354 |
|
1355 TRAPD(err, GetstreamableL(parser)); |
|
1356 if (err != KErrNone) |
|
1357 { |
|
1358 SetTestStepResult(EFail); |
|
1359 } |
|
1360 |
|
1361 CleanupStack::PopAndDestroy(parser); |
|
1362 } |
|
1363 return TestStepResult(); |
|
1364 } |
|
1365 |
|
1366 void C3GPLibParser_0007::GetstreamableL(C3GPParse* aParser) |
|
1367 { |
|
1368 // Open parser in File mode |
|
1369 ParserOpenFileL(aParser); |
|
1370 |
|
1371 // Check if the file is streamable |
|
1372 TBool streamable; |
|
1373 TInt err = aParser->GetStreamable(streamable); |
|
1374 if (err != KErrNone) |
|
1375 { |
|
1376 SetTestStepError(err); |
|
1377 } |
|
1378 else if (!streamable) |
|
1379 { |
|
1380 INFO_PRINTF2(_L("aParser->GetStreamable() returns %d"), streamable); |
|
1381 SetTestStepError(KErrNotSupported); |
|
1382 } |
|
1383 |
|
1384 ParserCompleteL(aParser); |
|
1385 } |
|
1386 |
|
1387 // ----------------------------------------------------------------------------- |
|
1388 // Check if the clip is streamable in buffer mode from a mp4/3gp/3g2 file |
|
1389 // ----------------------------------------------------------------------------- |
|
1390 // |
|
1391 C3GPLibParser_0008::C3GPLibParser_0008() |
|
1392 { |
|
1393 } |
|
1394 |
|
1395 TVerdict C3GPLibParser_0008::doTestStepL() |
|
1396 { |
|
1397 if(TestStepResult() == EPass) |
|
1398 { |
|
1399 C3GPParse* parser = C3GPParse::NewL(); |
|
1400 CleanupStack::PushL(parser); |
|
1401 |
|
1402 TRAPD(err, GetstreamableL(parser)); |
|
1403 if (err != KErrNone) |
|
1404 { |
|
1405 SetTestStepResult(EFail); |
|
1406 } |
|
1407 |
|
1408 CleanupStack::PopAndDestroy(parser); |
|
1409 } |
|
1410 return TestStepResult(); |
|
1411 } |
|
1412 |
|
1413 void C3GPLibParser_0008::GetstreamableL(C3GPParse* aParser) |
|
1414 { |
|
1415 // buffer mode |
|
1416 FileOpenL(); |
|
1417 ParserOpenL(aParser); |
|
1418 |
|
1419 // Check if the file is streamable before the data is inserted |
|
1420 TBool streamable; |
|
1421 TInt err = aParser->GetStreamable(streamable); |
|
1422 |
|
1423 // Insert 1K data to buffer |
|
1424 TInt bufferSize = 0; |
|
1425 TInt pos = 0; // from begining of the file |
|
1426 |
|
1427 // Insert data until enough data has been inserted |
|
1428 while (err == KErr3gpLibMoreDataRequired) |
|
1429 { |
|
1430 // Insert more data to buffer |
|
1431 pos = bufferSize + pos; |
|
1432 bufferSize = KBufferSize; |
|
1433 InsertDataL(aParser, iSourceFile, bufferSize, pos); |
|
1434 |
|
1435 err = aParser->GetStreamable(streamable); |
|
1436 } |
|
1437 |
|
1438 if (err != KErrNone) |
|
1439 { |
|
1440 if (!ShouldRunOOMTest()) |
|
1441 { |
|
1442 ERR_PRINTF2(_L("aParser->GetStreamable() returns %d"), err); |
|
1443 } |
|
1444 SetTestStepError(err); |
|
1445 } |
|
1446 |
|
1447 ParserCompleteL(aParser); |
|
1448 FileClose(); |
|
1449 } |
|
1450 |
|
1451 // ----------------------------------------------------------------------------- |
|
1452 // Retrieve buffered bytes, and video & audio frames synchronously in file mode |
|
1453 // ----------------------------------------------------------------------------- |
|
1454 // |
|
1455 C3GPLibParser_0011::C3GPLibParser_0011() |
|
1456 { |
|
1457 } |
|
1458 |
|
1459 TVerdict C3GPLibParser_0011::doTestStepL() |
|
1460 { |
|
1461 if(TestStepResult() == EPass) |
|
1462 { |
|
1463 C3GPParse* parser = C3GPParse::NewL(); |
|
1464 CleanupStack::PushL(parser); |
|
1465 |
|
1466 TRAPD(err, ReadFrameL(parser)); |
|
1467 if (err != KErrNone) |
|
1468 { |
|
1469 SetTestStepResult(EFail); |
|
1470 } |
|
1471 |
|
1472 CleanupStack::PopAndDestroy(parser); |
|
1473 } |
|
1474 return TestStepResult(); |
|
1475 } |
|
1476 |
|
1477 void C3GPLibParser_0011::ReadFrameL(C3GPParse* aParse) |
|
1478 { |
|
1479 // Parser open using File path |
|
1480 ParserOpenFileL(aParse); |
|
1481 User::LeaveIfError(DoReadFrame(aParse)); |
|
1482 ParserCompleteL(aParse); |
|
1483 |
|
1484 // Parser open using file handler |
|
1485 ParserOpenFileHandleL(aParse); |
|
1486 User::LeaveIfError(DoReadFrame(aParse)); |
|
1487 ParserCompleteHandleL(aParse); |
|
1488 |
|
1489 // Parser open using CAF |
|
1490 ParserOpenCafLC(aParse); |
|
1491 User::LeaveIfError(DoReadFrame(aParse)); |
|
1492 ParserCompleteCafL(aParse); |
|
1493 } |
|
1494 |
|
1495 // ----------------------------------------------------------------------------- |
|
1496 // Parse video & audio frames from a mp4/3gp file asynchronously in file mode |
|
1497 // ----------------------------------------------------------------------------- |
|
1498 // |
|
1499 C3GPLibParser_0014::C3GPLibParser_0014() |
|
1500 { |
|
1501 } |
|
1502 |
|
1503 TVerdict C3GPLibParser_0014::doTestStepPreambleL() |
|
1504 { |
|
1505 C3GPLib_AsyncObserver::doTestStepPreambleL(); |
|
1506 if (TestStepResult() == EPass) |
|
1507 { |
|
1508 iScheduler = new (ELeave) CActiveScheduler; |
|
1509 CActiveScheduler::Install(iScheduler); |
|
1510 } |
|
1511 return TestStepResult(); |
|
1512 } |
|
1513 |
|
1514 TVerdict C3GPLibParser_0014::doTestStepPostambleL() |
|
1515 { |
|
1516 C3GPLib_AsyncObserver::doTestStepPostambleL(); |
|
1517 if( iScheduler ) |
|
1518 { |
|
1519 INFO_PRINTF1(_L("delete iScheduler")); |
|
1520 CActiveScheduler::Install(NULL); |
|
1521 delete iScheduler; |
|
1522 iScheduler = NULL; |
|
1523 } |
|
1524 |
|
1525 return TestStepResult(); |
|
1526 } |
|
1527 |
|
1528 TVerdict C3GPLibParser_0014::doTestStepL() |
|
1529 { |
|
1530 if(TestStepResult() == EPass) |
|
1531 { |
|
1532 C3GPParse* parser = C3GPParse::NewL(); |
|
1533 CleanupStack::PushL(parser); |
|
1534 |
|
1535 TRAPD(err, ReadFrameAsyncL(parser)); |
|
1536 if (err != KErrNone) |
|
1537 { |
|
1538 SetTestStepResult(EFail); |
|
1539 } |
|
1540 |
|
1541 CleanupStack::PopAndDestroy(parser); |
|
1542 } |
|
1543 return TestStepResult(); |
|
1544 } |
|
1545 |
|
1546 void C3GPLibParser_0014::ReadFrameAsyncL(C3GPParse* aParser) |
|
1547 { |
|
1548 ParserOpenFileL(aParser); |
|
1549 User::LeaveIfError(DoReadFrameAsync(aParser)); |
|
1550 if (!ShouldRunOOMTest()) |
|
1551 { |
|
1552 INFO_PRINTF1(_L("C3GPLibParser_0014::ReadFrameAsyncL()")); |
|
1553 } |
|
1554 ParserCompleteL(aParser); |
|
1555 |
|
1556 ParserOpenFileL(aParser); |
|
1557 User::LeaveIfError(DoReadFrameAsync(aParser, ETrue)); |
|
1558 if (!ShouldRunOOMTest()) |
|
1559 { |
|
1560 INFO_PRINTF1(_L("C3GPLibParser_0014::ReadFrameAsyncL(), then cancel the read")); |
|
1561 } |
|
1562 ParserCompleteL(aParser); |
|
1563 |
|
1564 ParserOpenFileHandleL(aParser); |
|
1565 User::LeaveIfError(DoReadFrameAsync(aParser)); |
|
1566 if (!ShouldRunOOMTest()) |
|
1567 { |
|
1568 INFO_PRINTF1(_L("C3GPLibParser_0014::ReadFrameAsyncL() using file handler")); |
|
1569 } |
|
1570 ParserCompleteHandleL(aParser); |
|
1571 |
|
1572 ParserOpenCafLC(aParser); |
|
1573 User::LeaveIfError(DoReadFrameAsync(aParser)); |
|
1574 if (!ShouldRunOOMTest()) |
|
1575 { |
|
1576 INFO_PRINTF1(_L("C3GPLibParser_0014::ReadFrameAsyncL() using CAF")); |
|
1577 } |
|
1578 ParserCompleteCafL(aParser); |
|
1579 } |
|
1580 |
|
1581 TInt C3GPLibParser_0014::DoReadFrameAsync(C3GPParse* aParser, TBool aCancel) |
|
1582 { |
|
1583 TInt err = KErrNone; |
|
1584 |
|
1585 if (!aCancel) |
|
1586 { |
|
1587 err = ReadAudioVideoFrameAsync(aParser, ETrue); |
|
1588 if (err == KErrNone) |
|
1589 { |
|
1590 err = ReadAudioVideoFrameAsync(aParser, EFalse); |
|
1591 } |
|
1592 } |
|
1593 else |
|
1594 { |
|
1595 err = ReadAudioVideoFrameAsync(aParser, EFalse, ETrue); |
|
1596 } |
|
1597 |
|
1598 return err; |
|
1599 } |
|
1600 |
|
1601 // ----------------------------------------------------------------------------- |
|
1602 // Parse video & audio frames from a mp4/3gp file synchronously |
|
1603 // ----------------------------------------------------------------------------- |
|
1604 // |
|
1605 C3GPLibParser_0015::C3GPLibParser_0015() |
|
1606 { |
|
1607 } |
|
1608 |
|
1609 TVerdict C3GPLibParser_0015::doTestStepL() |
|
1610 { |
|
1611 if(TestStepResult() == EPass) |
|
1612 { |
|
1613 C3GPParse* parser = C3GPParse::NewL(); |
|
1614 CleanupStack::PushL(parser); |
|
1615 |
|
1616 TRAPD(err, ReadFrameL(parser)); |
|
1617 if (err != KErrNone) |
|
1618 { |
|
1619 SetTestStepResult(EFail); |
|
1620 } |
|
1621 |
|
1622 CleanupStack::PopAndDestroy(parser); |
|
1623 } |
|
1624 return TestStepResult(); |
|
1625 } |
|
1626 |
|
1627 void C3GPLibParser_0015::ReadFrameL(C3GPParse* aParser) |
|
1628 { |
|
1629 FileOpenL(); |
|
1630 ReadFrameBufferModeL(aParser); |
|
1631 FileClose(); |
|
1632 } |
|
1633 |
|
1634 // ----------------------------------------------------------------------------- |
|
1635 // Get frame type using file path |
|
1636 // ----------------------------------------------------------------------------- |
|
1637 // |
|
1638 C3GPLibParser_0016::C3GPLibParser_0016() |
|
1639 { |
|
1640 } |
|
1641 |
|
1642 |
|
1643 TVerdict C3GPLibParser_0016::doTestStepL() |
|
1644 { |
|
1645 if(TestStepResult() == EPass) |
|
1646 { |
|
1647 C3GPParse* parser = C3GPParse::NewL(); |
|
1648 CleanupStack::PushL(parser); |
|
1649 |
|
1650 TRAPD(err, GetFrameTypeL(parser)); |
|
1651 if (err != KErrNone) |
|
1652 { |
|
1653 SetTestStepResult(EFail); |
|
1654 } |
|
1655 |
|
1656 CleanupStack::PopAndDestroy(parser); |
|
1657 } |
|
1658 return TestStepResult(); |
|
1659 } |
|
1660 |
|
1661 void C3GPLibParser_0016::GetFrameTypeL(C3GPParse* aParser) |
|
1662 { |
|
1663 ParserOpenFileL(aParser); |
|
1664 |
|
1665 T3GPFrameType type; |
|
1666 TInt err = aParser->GetFrameType(type); |
|
1667 if (err == KErrNone) |
|
1668 { |
|
1669 TUint num; |
|
1670 err = aParser->GetNumberOfVideoFrames(num); |
|
1671 if (err == KErrNone) |
|
1672 { |
|
1673 // There is number of video in the file. Calling GetFrameType num+1 time won't affect |
|
1674 //the parser’s current position. It should return the same results |
|
1675 for (TInt i = 0; i < num; i++) |
|
1676 { |
|
1677 err = aParser->GetFrameType(type); |
|
1678 User::LeaveIfError(err); |
|
1679 } |
|
1680 err = aParser->GetFrameType(type); |
|
1681 User::LeaveIfError(err); |
|
1682 } |
|
1683 |
|
1684 if (!ShouldRunOOMTest()) |
|
1685 { |
|
1686 INFO_PRINTF2(_L("GetFrameType return type %d. "), type); |
|
1687 } |
|
1688 if (type == E3GPAudio) |
|
1689 { |
|
1690 // read 1 audio frame |
|
1691 err = ReadAudioVideoFrame(aParser, EFalse, ETrue); |
|
1692 User::LeaveIfError(CheckError(err, KErrNone, _L("ReadAudioVideoFrame"))); |
|
1693 |
|
1694 err = aParser->GetFrameType(type); |
|
1695 if (!ShouldRunOOMTest()) |
|
1696 { |
|
1697 INFO_PRINTF3(_L("After read 1 audio frame, GetFrameType return err %d; type %d. "), err, type); |
|
1698 } |
|
1699 SetTestStepError(err); |
|
1700 } |
|
1701 if (err == KErrNone && type == E3GPVideo) |
|
1702 { |
|
1703 // read 1 video frame |
|
1704 err = ReadAudioVideoFrame(aParser, EFalse, EFalse); |
|
1705 User::LeaveIfError(CheckError(err, KErrNone, _L("ReadAudioVideoFrame"))); |
|
1706 |
|
1707 err = aParser->GetFrameType(type); |
|
1708 SetTestStepError(err); |
|
1709 } |
|
1710 } |
|
1711 else |
|
1712 { |
|
1713 SetTestStepError(err); |
|
1714 } |
|
1715 ParserCompleteL(aParser); |
|
1716 } |
|
1717 |
|
1718 // ----------------------------------------------------------------------------- |
|
1719 // Get the QCELP storage mode in file path and buffer mode |
|
1720 // ----------------------------------------------------------------------------- |
|
1721 // |
|
1722 C3GPLibParser_0017::C3GPLibParser_0017() |
|
1723 { |
|
1724 } |
|
1725 |
|
1726 TVerdict C3GPLibParser_0017::doTestStepL() |
|
1727 { |
|
1728 if(TestStepResult() == EPass) |
|
1729 { |
|
1730 C3GPParse* parser = C3GPParse::NewL(); |
|
1731 CleanupStack::PushL(parser); |
|
1732 |
|
1733 TRAPD(err, GetQcelModeL(parser)); |
|
1734 if (err != KErrNone) |
|
1735 { |
|
1736 SetTestStepResult(EFail); |
|
1737 } |
|
1738 |
|
1739 CleanupStack::PopAndDestroy(parser); |
|
1740 } |
|
1741 return TestStepResult(); |
|
1742 } |
|
1743 |
|
1744 void C3GPLibParser_0017::GetQcelModeL(C3GPParse* aParser) |
|
1745 { |
|
1746 // file mode |
|
1747 ParserOpenFileL(aParser); |
|
1748 TInt err = KErrNone; |
|
1749 T3GPQcelpStorageMode mode; |
|
1750 err = aParser->GetQcelpStorageMode(mode); |
|
1751 if (err != KErrNone) |
|
1752 { |
|
1753 if (!ShouldRunOOMTest()) |
|
1754 { |
|
1755 ERR_PRINTF3(_L("aParser->GetQcelpStorageMode(mode) file mode return %d; mode %d. "), err, mode); |
|
1756 } |
|
1757 SetTestStepError(err); |
|
1758 } |
|
1759 |
|
1760 if ((iTestSection.Compare(KEsds) == 0 && mode != E3GPQcelpSampleEntryBox ) || |
|
1761 (iTestSection.Compare(KSqcp) == 0 && mode != E3GPMP4AudioDescriptionBox )) |
|
1762 { |
|
1763 User::Leave(KErrGeneral); |
|
1764 } |
|
1765 |
|
1766 ParserCompleteL(aParser); |
|
1767 |
|
1768 // buffer mode |
|
1769 ParserOpenL(aParser); |
|
1770 FileOpenL(); |
|
1771 |
|
1772 // Insert 1K data into the library |
|
1773 TInt pos = 0; |
|
1774 TInt bufferSize = 1000; |
|
1775 |
|
1776 InsertDataL(aParser, iSourceFile, bufferSize, pos); |
|
1777 err = aParser->GetQcelpStorageMode(mode); |
|
1778 |
|
1779 while (err == KErr3gpLibMoreDataRequired ) |
|
1780 { |
|
1781 pos = pos + bufferSize; |
|
1782 InsertDataL(aParser, iSourceFile, bufferSize, pos); |
|
1783 err = aParser->GetQcelpStorageMode(mode); |
|
1784 } |
|
1785 |
|
1786 if (err != KErrNone) |
|
1787 { |
|
1788 if (!ShouldRunOOMTest()) |
|
1789 { |
|
1790 ERR_PRINTF3(_L("aParser->GetQcelpStorageMode(mode) file mode return %d; mode %d. "), err, mode); |
|
1791 } |
|
1792 SetTestStepError(err); |
|
1793 } |
|
1794 |
|
1795 if ((iTestSection.Compare(KEsds) == 0 && mode != E3GPQcelpSampleEntryBox ) || |
|
1796 (iTestSection.Compare(KSqcp) == 0 && mode != E3GPMP4AudioDescriptionBox )) |
|
1797 { |
|
1798 User::Leave(KErrGeneral); |
|
1799 } |
|
1800 |
|
1801 ParserCompleteL(aParser); |
|
1802 FileClose(); |
|
1803 } |
|
1804 |
|
1805 // ----------------------------------------------------------------------------- |
|
1806 // Get H263 video leve in file path and buffer mode. |
|
1807 // ----------------------------------------------------------------------------- |
|
1808 // |
|
1809 C3GPLibParser_0021::C3GPLibParser_0021() |
|
1810 { |
|
1811 } |
|
1812 |
|
1813 TVerdict C3GPLibParser_0021::doTestStepL() |
|
1814 { |
|
1815 if(TestStepResult() == EPass) |
|
1816 { |
|
1817 C3GPParse* parser = C3GPParse::NewL(); |
|
1818 CleanupStack::PushL(parser); |
|
1819 |
|
1820 TRAPD(err, GetH263LevelL(parser)); |
|
1821 if (err != KErrNone) |
|
1822 { |
|
1823 SetTestStepResult(EFail); |
|
1824 } |
|
1825 |
|
1826 CleanupStack::PopAndDestroy(parser); |
|
1827 } |
|
1828 return TestStepResult(); |
|
1829 } |
|
1830 |
|
1831 void C3GPLibParser_0021::GetH263LevelL(C3GPParse* aParser) |
|
1832 { |
|
1833 // file mode |
|
1834 ParserOpenFileL(aParser); |
|
1835 TInt err = KErrNone; |
|
1836 TInt level; |
|
1837 err = aParser->GetH263VideoLevel(level); |
|
1838 if (err != KErrNone) |
|
1839 { |
|
1840 if (!ShouldRunOOMTest()) |
|
1841 { |
|
1842 ERR_PRINTF3(_L("aParser->GetH263VideoLevel() file mode return %d; level %d. "), err, level); |
|
1843 } |
|
1844 SetTestStepError(err); |
|
1845 } |
|
1846 |
|
1847 ParserCompleteL(aParser); |
|
1848 |
|
1849 // buffer mode |
|
1850 ParserOpenL(aParser); |
|
1851 FileOpenL(); |
|
1852 |
|
1853 // Insert 1K data into the library |
|
1854 TInt pos = 0; |
|
1855 TInt bufferSize = KBufferSize; |
|
1856 |
|
1857 InsertDataL(aParser, iSourceFile, bufferSize, pos); |
|
1858 err = aParser->GetH263VideoLevel(level);; |
|
1859 |
|
1860 while (err == KErr3gpLibMoreDataRequired ) |
|
1861 { |
|
1862 pos = pos + bufferSize; |
|
1863 InsertDataL(aParser, iSourceFile, bufferSize, pos); |
|
1864 err = aParser->GetH263VideoLevel(level);; |
|
1865 } |
|
1866 |
|
1867 if (err != KErrNone) |
|
1868 { |
|
1869 if (!ShouldRunOOMTest()) |
|
1870 { |
|
1871 ERR_PRINTF3(_L("aParser->GetH263VideoLevel() file mode return %d; level %d. "), err, level); |
|
1872 } |
|
1873 SetTestStepError(err); |
|
1874 } |
|
1875 |
|
1876 ParserCompleteL(aParser); |
|
1877 FileClose(); |
|
1878 } |
|
1879 |
|
1880 // ----------------------------------------------------------------------------- |
|
1881 // Read Video and audio Decoder Info size and info in file path and buffer mode. |
|
1882 // ----------------------------------------------------------------------------- |
|
1883 // |
|
1884 C3GPLibParser_0023::C3GPLibParser_0023() |
|
1885 { |
|
1886 } |
|
1887 |
|
1888 TVerdict C3GPLibParser_0023::doTestStepL() |
|
1889 { |
|
1890 if(TestStepResult() == EPass) |
|
1891 { |
|
1892 C3GPParse* parser = C3GPParse::NewL(); |
|
1893 CleanupStack::PushL(parser); |
|
1894 |
|
1895 TRAPD(err, GetDecoderInfoL(parser)); |
|
1896 if (err != KErrNone) |
|
1897 { |
|
1898 SetTestStepResult(EFail); |
|
1899 } |
|
1900 |
|
1901 CleanupStack::PopAndDestroy(parser); |
|
1902 } |
|
1903 return TestStepResult(); |
|
1904 } |
|
1905 |
|
1906 void C3GPLibParser_0023::GetDecoderInfoL(C3GPParse* aParser) |
|
1907 { |
|
1908 // file mode |
|
1909 ParserOpenFileL(aParser); |
|
1910 |
|
1911 TInt errReadAudio = KErrNone; |
|
1912 TInt errReadVideo = KErrNone; |
|
1913 // Retrieve the info with buffer size = 0. Should fail with KErrOverflow |
|
1914 RBuf8 dsiBuffer; |
|
1915 CleanupClosePushL(dsiBuffer); |
|
1916 dsiBuffer.CreateL(0); |
|
1917 errReadAudio = aParser->GetAudioDecoderSpecificInfo(dsiBuffer); |
|
1918 errReadVideo = aParser->GetVideoDecoderSpecificInfo(dsiBuffer); |
|
1919 |
|
1920 if (errReadAudio == KErrOverflow && errReadVideo == KErrOverflow) |
|
1921 { |
|
1922 errReadAudio = ParserGetDecoderInfo(aParser); |
|
1923 |
|
1924 if (errReadAudio != KErrNone) |
|
1925 { |
|
1926 ERR_PRINTF2(_L("ParserGetDecoderInfo file mode return %d; "), errReadAudio); |
|
1927 User::Leave(errReadAudio); |
|
1928 } |
|
1929 } |
|
1930 else |
|
1931 { |
|
1932 ERR_PRINTF2(_L("ParserGetDecoderInfo file mode expected KErrOverflow, but return %d; "), errReadAudio); |
|
1933 User::Leave(errReadAudio); |
|
1934 } |
|
1935 |
|
1936 ParserCompleteL(aParser); |
|
1937 |
|
1938 // buffer mode |
|
1939 ParserOpenL(aParser); |
|
1940 FileOpenL(); |
|
1941 |
|
1942 // Insert 1K data into the library |
|
1943 TInt pos = 0; |
|
1944 TInt bufferSize = KBufferSize; |
|
1945 |
|
1946 InsertDataL(aParser, iSourceFile, bufferSize, pos); |
|
1947 |
|
1948 // Retrieve the info with buffer size = 0. Should fail with KErrOverflow |
|
1949 dsiBuffer.Close(); |
|
1950 dsiBuffer.CreateL(0); |
|
1951 errReadAudio = aParser->GetAudioDecoderSpecificInfo(dsiBuffer); |
|
1952 errReadVideo = aParser->GetVideoDecoderSpecificInfo(dsiBuffer); |
|
1953 CleanupStack::PopAndDestroy(&dsiBuffer); |
|
1954 |
|
1955 if (errReadAudio != KErrOverflow || errReadVideo != KErrOverflow) |
|
1956 { |
|
1957 ERR_PRINTF2(_L("ParserGetDecoderInfo buffer mode expected KErrOverflow, but return %d; "), errReadAudio); |
|
1958 User::Leave(errReadAudio); |
|
1959 } |
|
1960 errReadAudio = ParserGetDecoderInfo(aParser); |
|
1961 |
|
1962 while (errReadAudio == KErr3gpLibMoreDataRequired ) |
|
1963 { |
|
1964 pos = pos + bufferSize; |
|
1965 InsertDataL(aParser, iSourceFile, bufferSize, pos); |
|
1966 errReadAudio = ParserGetDecoderInfo(aParser); |
|
1967 } |
|
1968 if (!ShouldRunOOMTest()) |
|
1969 { |
|
1970 INFO_PRINTF2(_L("ParserGetDecoderInfo(aParser) buffer mode return %d. "), errReadAudio); |
|
1971 } |
|
1972 ParserCompleteL(aParser); |
|
1973 FileClose(); |
|
1974 } |
|
1975 |
|
1976 // ----------------------------------------------------------------------------- |
|
1977 // Seek different position of a video/audio file |
|
1978 // ----------------------------------------------------------------------------- |
|
1979 // |
|
1980 C3GPLibParser_0027::C3GPLibParser_0027() |
|
1981 { |
|
1982 } |
|
1983 |
|
1984 TVerdict C3GPLibParser_0027::doTestStepL() |
|
1985 { |
|
1986 if(TestStepResult() == EPass) |
|
1987 { |
|
1988 C3GPParse* parser = C3GPParse::NewL(); |
|
1989 CleanupStack::PushL(parser); |
|
1990 |
|
1991 TRAPD(err, SeekTestL(parser)); |
|
1992 if (err != KErrNone) |
|
1993 { |
|
1994 SetTestStepResult(EFail); |
|
1995 } |
|
1996 |
|
1997 CleanupStack::PopAndDestroy(parser); |
|
1998 } |
|
1999 return TestStepResult(); |
|
2000 } |
|
2001 |
|
2002 void C3GPLibParser_0027::SeekTestL(C3GPParse* aParse) |
|
2003 { |
|
2004 // file mode |
|
2005 ParserOpenFileL(aParse); |
|
2006 |
|
2007 TUint audioPos; |
|
2008 TUint videoPos; |
|
2009 TUint timeStampInMs = 0; |
|
2010 |
|
2011 // Seek to position 0. |
|
2012 TInt err = KErrNone; |
|
2013 if (iTestSection.Compare(KNoAudioNoVideo) != 0) |
|
2014 { |
|
2015 // Retrieve video & audio stream length |
|
2016 TUint videoLength; |
|
2017 TUint audioLength; |
|
2018 TInt videoError; |
|
2019 |
|
2020 err = GetClipProperties(aParse, videoError, videoLength, audioLength); |
|
2021 if (iTestSection.Compare(KAudioOnly) == 0) |
|
2022 { |
|
2023 // audio only, GetVideoProperties should fail with KErrNotSupported. Set video length to 0 |
|
2024 User::LeaveIfError(CheckError(videoError, KErrNotSupported, _L("GetClipProperties(aParse, videoError, videoLength, audioLength))"))); |
|
2025 videoLength = 0; |
|
2026 } |
|
2027 else if (iTestSection.Compare(KVideoOnly) == 0) |
|
2028 { |
|
2029 // video only, GetAudioProperties should fail with KErrNotSupported. Set audio length to 0 |
|
2030 User::LeaveIfError(CheckError(err, KErrNotSupported, _L("GetClipProperties(aParse, videoError, videoLength, audioLength)"))); |
|
2031 audioLength = 0; |
|
2032 } |
|
2033 else |
|
2034 { |
|
2035 // All other files contains audio and video data |
|
2036 User::LeaveIfError(CheckError(videoError, KErrNone, _L("GetClipProperties(aParse, videoError, videoLength, audioLength)"))); |
|
2037 User::LeaveIfError(CheckError(err, KErrNone, _L("GetClipProperties(aParse, videoError, videoLength, audioLength)"))); |
|
2038 } |
|
2039 |
|
2040 if (audioLength >= videoLength) |
|
2041 { |
|
2042 timeStampInMs = audioLength; |
|
2043 } |
|
2044 else |
|
2045 { |
|
2046 timeStampInMs = videoLength; |
|
2047 } |
|
2048 |
|
2049 if (iTestSection.Compare(KSameLenAudioVideo) == 0 || iTestSection.Compare(KAudioOnly) == 0) |
|
2050 { |
|
2051 err = ParserSeek(aParse, timeStampInMs, audioPos, videoPos); |
|
2052 User::LeaveIfError(err); |
|
2053 } |
|
2054 |
|
2055 if (iTestSection.Compare(KAudioMore) == 0 || iTestSection.Compare(KVideoMore) == 0 ) |
|
2056 { |
|
2057 timeStampInMs = (audioLength + videoLength)/2; |
|
2058 err = aParse->Seek(timeStampInMs, EFalse, audioPos, videoPos); |
|
2059 User::LeaveIfError(err); |
|
2060 } |
|
2061 } |
|
2062 |
|
2063 ParserCompleteL(aParse); |
|
2064 } |
|
2065 |
|
2066 // Seek position 0, half the length and the length of the stream |
|
2067 TInt C3GPLibParser_0027::ParserSeek(C3GPParse* aParser, TInt aLen, TUint& aAudioPos, TUint& aVideoPos) |
|
2068 { |
|
2069 TInt err = KErrNone; |
|
2070 TUint position = 0; |
|
2071 while (err == KErrNone && position <= aLen) |
|
2072 { |
|
2073 err = aParser->Seek(position, ETrue, aAudioPos, aVideoPos); |
|
2074 if (err == KErrNone) |
|
2075 { |
|
2076 err = aParser->Seek(position, EFalse, aAudioPos, aVideoPos); |
|
2077 } |
|
2078 position = position + aLen/2; |
|
2079 } |
|
2080 |
|
2081 if (err != KErrNone) |
|
2082 { |
|
2083 ERR_PRINTF3(_L("aParser->Seek() failed with %d when positon is %d"), err, position); |
|
2084 } |
|
2085 return err; |
|
2086 } |
|
2087 |
|
2088 // ----------------------------------------------------------------------------- |
|
2089 // Seek positions after any keyframe and immediately after a non-key frame. |
|
2090 // ----------------------------------------------------------------------------- |
|
2091 // |
|
2092 C3GPLibParser_0031::C3GPLibParser_0031() |
|
2093 { |
|
2094 } |
|
2095 |
|
2096 TVerdict C3GPLibParser_0031::doTestStepL() |
|
2097 { |
|
2098 if(TestStepResult() == EPass) |
|
2099 { |
|
2100 C3GPParse* parser = C3GPParse::NewL(); |
|
2101 CleanupStack::PushL(parser); |
|
2102 |
|
2103 TRAPD(err, SeekTestL(parser)); |
|
2104 if (err != KErrNone) |
|
2105 { |
|
2106 SetTestStepResult(EFail); |
|
2107 } |
|
2108 |
|
2109 CleanupStack::PopAndDestroy(parser); |
|
2110 } |
|
2111 return TestStepResult(); |
|
2112 } |
|
2113 |
|
2114 void C3GPLibParser_0031::SeekTestL(C3GPParse* aParser) |
|
2115 { |
|
2116 // file mode |
|
2117 ParserOpenFileL(aParser); |
|
2118 DoSeekTestL(aParser); |
|
2119 ParserCompleteL(aParser); |
|
2120 } |
|
2121 |
|
2122 // ----------------------------------------------------------------------------- |
|
2123 // Check frame availability using file path |
|
2124 // ----------------------------------------------------------------------------- |
|
2125 // |
|
2126 C3GPLibParser_0032::C3GPLibParser_0032() |
|
2127 { |
|
2128 } |
|
2129 |
|
2130 TVerdict C3GPLibParser_0032::doTestStepL() |
|
2131 { |
|
2132 if(TestStepResult() == EPass) |
|
2133 { |
|
2134 C3GPParse* parser = C3GPParse::NewL(); |
|
2135 CleanupStack::PushL(parser); |
|
2136 |
|
2137 TRAPD(err, GetFrameAvailabilityL(parser)); |
|
2138 if (err != KErrNone) |
|
2139 { |
|
2140 SetTestStepResult(EFail); |
|
2141 } |
|
2142 |
|
2143 CleanupStack::PopAndDestroy(parser); |
|
2144 } |
|
2145 return TestStepResult(); |
|
2146 } |
|
2147 |
|
2148 void C3GPLibParser_0032::GetFrameAvailabilityL(C3GPParse* aParser) |
|
2149 { |
|
2150 // file mode |
|
2151 ParserOpenFileL(aParser); |
|
2152 DoGetFrameAvailabilityL(aParser); |
|
2153 ParserCompleteL(aParser); |
|
2154 } |
|
2155 |
|
2156 void C3GPLibParser_0032::DoGetFrameAvailabilityL(C3GPParse* aParser) |
|
2157 { |
|
2158 T3GPFrameType audioType = E3GPAudio; |
|
2159 T3GPFrameType videoType = E3GPVideo; |
|
2160 TBool audioAvailable; |
|
2161 TBool videoAvailable; |
|
2162 TUint num; |
|
2163 TInt audioErr = aParser->GetFrameAvailability(audioType, audioAvailable); |
|
2164 if (audioErr != KErrNone && audioErr != KErrNotFound) |
|
2165 { |
|
2166 SetTestStepError(audioErr); |
|
2167 User::LeaveIfError(audioErr); |
|
2168 } |
|
2169 |
|
2170 TInt videoErr = aParser->GetFrameAvailability(videoType, videoAvailable); |
|
2171 if (videoErr != KErrNone && videoErr != KErrNotFound) |
|
2172 { |
|
2173 SetTestStepError(videoErr); |
|
2174 User::LeaveIfError(videoErr); |
|
2175 } |
|
2176 |
|
2177 TInt err = aParser->GetNumberOfVideoFrames(num); |
|
2178 if (err != KErrNone && err != KErrNotSupported) |
|
2179 { |
|
2180 SetTestStepError(err); |
|
2181 User::LeaveIfError(err); |
|
2182 } |
|
2183 |
|
2184 if (iTestSection.Compare(KNoAudioNoVideo) == 0) |
|
2185 { |
|
2186 if (audioErr != KErrNotFound || videoErr != KErrNotFound |
|
2187 || audioAvailable || videoAvailable) |
|
2188 { |
|
2189 ERR_PRINTF2(_L("GetFrameAvailability() audio failed with %d, expected KErrNotFound"), audioErr); |
|
2190 ERR_PRINTF2(_L("GetFrameAvailability() expected audioAvailable returns false, actual %d "), audioAvailable); |
|
2191 ERR_PRINTF2(_L("GetFrameAvailability() video failed with %d, expected KErrNotFound;"), videoErr); |
|
2192 ERR_PRINTF2(_L("GetFrameAvailability() expected videoAvailable returns false, actual %d "), videoAvailable); |
|
2193 User::Leave(KErrGeneral); |
|
2194 } |
|
2195 User::LeaveIfError(CheckError(err, KErrNotSupported, _L("aParser->GetNumberOfVideoFrames(num)"))); |
|
2196 } |
|
2197 else if (iTestSection.Compare(KAudioOnly) == 0) |
|
2198 { |
|
2199 if (audioErr != KErrNone || videoErr != KErrNotFound |
|
2200 || !audioAvailable || videoAvailable) |
|
2201 { |
|
2202 ERR_PRINTF2(_L("aParser->GetFrameAvailability() audio failed with %d, expected KErrNone"), audioErr); |
|
2203 ERR_PRINTF2(_L("aParser->GetFrameAvailability() expected audioAvailable returns True, actual %d "), audioAvailable); |
|
2204 ERR_PRINTF2(_L("aParser->GetFrameAvailability() video failed with %d, expected KErrNotFound;"), videoErr); |
|
2205 ERR_PRINTF2(_L("aParser->GetFrameAvailability() expected videoAvailable returns false, actual %d"), videoAvailable); |
|
2206 User::Leave(KErrGeneral); |
|
2207 } |
|
2208 User::LeaveIfError(CheckError(err, KErrNotSupported, _L("aParser->GetNumberOfVideoFrames(num)"))); |
|
2209 } |
|
2210 else if (iTestSection.Compare(KVideoOnly) == 0) |
|
2211 { |
|
2212 if (audioErr != KErrNotFound || videoErr != KErrNone |
|
2213 || audioAvailable || !videoAvailable) |
|
2214 { |
|
2215 ERR_PRINTF2(_L("aParser->GetFrameAvailability() audio failed with %d, expected KErrNotFound"), audioErr); |
|
2216 ERR_PRINTF2(_L("aParser->GetFrameAvailability() expected audioAvailable returns false, actual %d "), audioAvailable); |
|
2217 ERR_PRINTF2(_L("aParser->GetFrameAvailability() video failed with %d, expected KErrNone;"), videoErr); |
|
2218 ERR_PRINTF2(_L("aParser->GetFrameAvailability() expected videoAvailable returns true, actual %d"), videoAvailable); |
|
2219 User::Leave(KErrGeneral); |
|
2220 } |
|
2221 User::LeaveIfError(CheckError(err, KErrNone, _L("aParser->GetNumberOfVideoFrames(num)"))); |
|
2222 if (num != 265) |
|
2223 { |
|
2224 ERR_PRINTF2(_L("file h263-no-audio.MP4 has 265 video frames. Got %d instread"), num); |
|
2225 User::Leave(KErrGeneral); |
|
2226 } |
|
2227 } |
|
2228 else // File contains both valid audio and video data |
|
2229 { |
|
2230 // If file contains avc profile main or extended, videoErr could be KErrNotFound |
|
2231 if (audioErr != KErrNone || !audioAvailable) |
|
2232 { |
|
2233 ERR_PRINTF2(_L("aParser->GetFrameAvailability() audio failed with %d, expected KErrNone"), audioErr); |
|
2234 ERR_PRINTF2(_L("aParser->GetFrameAvailability() expected audioAvailable returns True, actual %d "), audioAvailable); |
|
2235 ERR_PRINTF2(_L("aParser->GetFrameAvailability() video failed with %d, expected KErrNone;"), videoErr); |
|
2236 ERR_PRINTF2(_L("aParser->GetFrameAvailability() expected videoAvailable returns True, actual %d"), videoAvailable); |
|
2237 User::Leave(KErrGeneral); |
|
2238 } |
|
2239 if (videoErr != KErrNone) |
|
2240 { |
|
2241 SetTestStepError(videoErr); |
|
2242 } |
|
2243 else |
|
2244 { |
|
2245 User::LeaveIfError(CheckError(err, KErrNone, _L("aParser->GetNumberOfVideoFrames(num)"))); |
|
2246 } |
|
2247 } |
|
2248 } |
|
2249 |
|
2250 // ----------------------------------------------------------------------------- |
|
2251 // Retrieve video frame size & start time without parsing the content file frame |
|
2252 // by frame in file mode |
|
2253 // ----------------------------------------------------------------------------- |
|
2254 // |
|
2255 C3GPLibParser_0033::C3GPLibParser_0033() |
|
2256 { |
|
2257 } |
|
2258 |
|
2259 TVerdict C3GPLibParser_0033::doTestStepL() |
|
2260 { |
|
2261 if(TestStepResult() == EPass) |
|
2262 { |
|
2263 C3GPParse* parser = C3GPParse::NewL(); |
|
2264 CleanupStack::PushL(parser); |
|
2265 |
|
2266 TRAPD(err, VideoInfoL(parser)); |
|
2267 if (err != KErrNone) |
|
2268 { |
|
2269 SetTestStepResult(EFail); |
|
2270 } |
|
2271 |
|
2272 CleanupStack::PopAndDestroy(parser); |
|
2273 } |
|
2274 return TestStepResult(); |
|
2275 } |
|
2276 |
|
2277 void C3GPLibParser_0033::VideoInfoL(C3GPParse* aParser) |
|
2278 { |
|
2279 // file mode |
|
2280 ParserOpenFileL(aParser); |
|
2281 |
|
2282 TUint num; |
|
2283 TInt num1 = 0; |
|
2284 TUint timeStampInMs = 0; |
|
2285 TUint timeStampInTimescale = 0; |
|
2286 TUint timeStampInMs1 = 0; |
|
2287 TUint timeStampInTimescale1 = 0; |
|
2288 TUint frameIndex; |
|
2289 TUint frameSize; |
|
2290 TBool keyFrame; |
|
2291 User::LeaveIfError(aParser->GetNumberOfVideoFrames(num)); |
|
2292 |
|
2293 RBuf8 buffer; |
|
2294 CleanupClosePushL(buffer); |
|
2295 buffer.CreateL(0); |
|
2296 TInt err = aParser->ReadVideoFrame(buffer, keyFrame, timeStampInMs, timeStampInTimescale); |
|
2297 if (err != KErrOverflow) |
|
2298 { |
|
2299 ERR_PRINTF2(_L("aParser->ReadVideoFrame() expected KErrOverflow, actual %d"), err); |
|
2300 User::Leave(err); |
|
2301 } |
|
2302 User::LeaveIfError(aParser->GetVideoSampleEntryIndex(frameIndex)); |
|
2303 CleanupStack::PopAndDestroy(&buffer); |
|
2304 |
|
2305 |
|
2306 err = KErrNone; |
|
2307 while (err == KErrNone) |
|
2308 { |
|
2309 timeStampInMs = 0; |
|
2310 timeStampInTimescale = 0; |
|
2311 timeStampInMs1 = 0; |
|
2312 timeStampInTimescale1 = 0; |
|
2313 |
|
2314 if (num1 < num) |
|
2315 { |
|
2316 User::LeaveIfError(aParser->GetVideoFrameSize(num1, frameSize)); |
|
2317 User::LeaveIfError(aParser->GetVideoFrameStartTime(num1, timeStampInMs, timeStampInTimescale)); |
|
2318 } |
|
2319 else |
|
2320 { |
|
2321 err = aParser->GetVideoFrameStartTime(num1, timeStampInMs, timeStampInTimescale); |
|
2322 err = aParser->GetVideoFrameSize(num1, frameSize); |
|
2323 } |
|
2324 RBuf8 buffer1; |
|
2325 CleanupClosePushL(buffer1); |
|
2326 buffer1.CreateL(frameSize); |
|
2327 err = aParser->ReadVideoFrame(buffer1, keyFrame, timeStampInMs1, timeStampInTimescale1); |
|
2328 |
|
2329 if (timeStampInMs != timeStampInMs1) |
|
2330 { |
|
2331 ERR_PRINTF3(_L("Two timestamps should be the same. timeStampInMs %d, timeStampInMs1 %d"), timeStampInMs, timeStampInMs1); |
|
2332 User::Leave(KErrGeneral); |
|
2333 } |
|
2334 CleanupStack::PopAndDestroy(&buffer1); |
|
2335 num1++; |
|
2336 } |
|
2337 |
|
2338 if (err != KErrNotFound) |
|
2339 { |
|
2340 ERR_PRINTF2(_L("expected KErrNotFound when finishing reading video frames. Actual err %d"), err); |
|
2341 User::Leave(KErrGeneral); |
|
2342 } |
|
2343 |
|
2344 if ((num1 - 1) != num) |
|
2345 { |
|
2346 ERR_PRINTF3(_L("Two numOfFrame should be the same. num %d, num1 %d"), num, num1); |
|
2347 User::Leave(KErrGeneral); |
|
2348 } |
|
2349 |
|
2350 // use an invalid index to attempt retrieving video frame size & start time. Both should failed with error. |
|
2351 err = aParser->GetVideoFrameSize((num + 100), frameSize); |
|
2352 User::LeaveIfError(CheckError(err, KErrGeneral, _L("GetVideoFrameSize"))); |
|
2353 |
|
2354 err = aParser->GetVideoFrameStartTime((num + 5), timeStampInMs, timeStampInTimescale); |
|
2355 User::LeaveIfError(CheckError(err, KErrGeneral, _L("GetVideoFrameStartTime"))); |
|
2356 |
|
2357 ParserCompleteL(aParser); |
|
2358 } |
|
2359 |
|
2360 // ----------------------------------------------------------------------------- |
|
2361 // Retrieve video frame size & start time without parsing the content file frame |
|
2362 // by frame in buffe mode |
|
2363 // ----------------------------------------------------------------------------- |
|
2364 // |
|
2365 C3GPLibParser_0034::C3GPLibParser_0034() |
|
2366 { |
|
2367 } |
|
2368 |
|
2369 TVerdict C3GPLibParser_0034::doTestStepL() |
|
2370 { |
|
2371 if(TestStepResult() == EPass) |
|
2372 { |
|
2373 C3GPParse* parser = C3GPParse::NewL(); |
|
2374 CleanupStack::PushL(parser); |
|
2375 |
|
2376 TRAPD(err, VideoInfoBufferModeL(parser)); |
|
2377 if (err != KErrNone) |
|
2378 { |
|
2379 SetTestStepResult(EFail); |
|
2380 } |
|
2381 |
|
2382 CleanupStack::PopAndDestroy(parser); |
|
2383 } |
|
2384 return TestStepResult(); |
|
2385 } |
|
2386 |
|
2387 void C3GPLibParser_0034::VideoInfoBufferModeL(C3GPParse* aParser) |
|
2388 { |
|
2389 // buffer mode |
|
2390 ParserOpenL(aParser); |
|
2391 FileOpenL(); |
|
2392 |
|
2393 TUint num; |
|
2394 TUint timeStampInMs = 0; |
|
2395 TUint timeStampInTimescale = 0; |
|
2396 TUint frameSize; |
|
2397 |
|
2398 // Insert 1K data into the library |
|
2399 TInt pos = 0; |
|
2400 TInt bufferSize = KBufferSize; |
|
2401 InsertDataL(aParser, iSourceFile, bufferSize, pos); |
|
2402 TInt err = aParser->GetNumberOfVideoFrames(num); |
|
2403 if (err != KErrNone && err != KErrNotSupported && err != KErr3gpLibMoreDataRequired) |
|
2404 { |
|
2405 SetTestStepError(err); |
|
2406 User::LeaveIfError(err); |
|
2407 } |
|
2408 |
|
2409 while (err == KErr3gpLibMoreDataRequired ) |
|
2410 { |
|
2411 pos = pos + bufferSize; |
|
2412 InsertDataL(aParser, iSourceFile, bufferSize, pos); |
|
2413 err = aParser->GetNumberOfVideoFrames(num); |
|
2414 } |
|
2415 |
|
2416 if (err != KErrNone) |
|
2417 { |
|
2418 SetTestStepError(err); |
|
2419 } |
|
2420 else |
|
2421 { |
|
2422 for (TUint i = 0; i < num; i++) |
|
2423 { |
|
2424 User::LeaveIfError(aParser->GetVideoFrameSize(i, frameSize)); |
|
2425 User::LeaveIfError(aParser->GetVideoFrameStartTime(i, timeStampInMs, timeStampInTimescale)); |
|
2426 } |
|
2427 } |
|
2428 |
|
2429 ParserCompleteL(aParser); |
|
2430 FileClose(); |
|
2431 } |
|
2432 |
|
2433 // ----------------------------------------------------------------------------- |
|
2434 // Retrieve user atoms in all the possible locations |
|
2435 // ----------------------------------------------------------------------------- |
|
2436 // |
|
2437 C3GPLibParser_0035::C3GPLibParser_0035() |
|
2438 { |
|
2439 } |
|
2440 |
|
2441 TVerdict C3GPLibParser_0035::doTestStepL() |
|
2442 { |
|
2443 if(TestStepResult() == EPass) |
|
2444 { |
|
2445 C3GPParse* parser = C3GPParse::NewL(); |
|
2446 CleanupStack::PushL(parser); |
|
2447 |
|
2448 TRAPD(err, GetUserDataAtomL(parser)); |
|
2449 if (err != KErrNone) |
|
2450 { |
|
2451 SetTestStepResult(EFail); |
|
2452 } |
|
2453 |
|
2454 CleanupStack::PopAndDestroy(parser); |
|
2455 } |
|
2456 return TestStepResult(); |
|
2457 } |
|
2458 |
|
2459 void C3GPLibParser_0035::GetUserDataAtomL(C3GPParse* aParse) |
|
2460 { |
|
2461 // file mode |
|
2462 ParserOpenFileL(aParse); |
|
2463 |
|
2464 TUint32 udtType = 0x6d657461; // The udt type of test files is 'meta' |
|
2465 T3GPUdtaLocation location = E3GPUdtaAudioTrak; |
|
2466 TUint indexMoov = 0; |
|
2467 TUint indexAudio = 0; |
|
2468 TUint indexVideo = 0; |
|
2469 |
|
2470 TInt err = CallUDTApi(aParse, udtType, indexAudio, location); |
|
2471 if (err == KErrNone) |
|
2472 { |
|
2473 location = E3GPUdtaMoov; |
|
2474 err = CallUDTApi(aParse, udtType, indexMoov, location); |
|
2475 |
|
2476 if (err == KErrNone) |
|
2477 { |
|
2478 // By default, the location is video track |
|
2479 err = CallUDTApi(aParse, udtType, indexVideo); |
|
2480 } |
|
2481 if (err == KErrNone) |
|
2482 { |
|
2483 // Test file KMultiUdta contains 1 udta at E3GPUdtaMoov, 5 udta at E3GPUdtaAudioTrak and |
|
2484 // 3 udta at E3GPUdtaVideoTrak |
|
2485 if (iTestSection.Compare(KMultiUdta) == 0 && (indexMoov != 0 || indexAudio != 4 || indexVideo != 2)) |
|
2486 { |
|
2487 SetTestStepError(KErrNotFound); |
|
2488 } |
|
2489 } |
|
2490 } |
|
2491 |
|
2492 SetTestStepError(err); |
|
2493 |
|
2494 ParserCompleteL(aParse); |
|
2495 } |
|
2496 |
|
2497 // ----------------------------------------------------------------------------- |
|
2498 // Retrieve user atoms from a valid mp4/3gp file containing multiple entries of |
|
2499 // the same user atom type within a user atom |
|
2500 // ----------------------------------------------------------------------------- |
|
2501 // |
|
2502 C3GPLibParser_0036::C3GPLibParser_0036() |
|
2503 { |
|
2504 } |
|
2505 |
|
2506 TVerdict C3GPLibParser_0036::doTestStepL() |
|
2507 { |
|
2508 if(TestStepResult() == EPass) |
|
2509 { |
|
2510 C3GPParse* parser = C3GPParse::NewL(); |
|
2511 CleanupStack::PushL(parser); |
|
2512 |
|
2513 TRAPD(err, GetUserDataAtomL(parser)); |
|
2514 if (err != KErrNone) |
|
2515 { |
|
2516 SetTestStepResult(EFail); |
|
2517 } |
|
2518 |
|
2519 CleanupStack::PopAndDestroy(parser); |
|
2520 } |
|
2521 return TestStepResult(); |
|
2522 } |
|
2523 |
|
2524 void C3GPLibParser_0036::GetUserDataAtomL(C3GPParse* aParse) |
|
2525 { |
|
2526 // file mode |
|
2527 ParserOpenFileL(aParse); |
|
2528 |
|
2529 TUint index; |
|
2530 TUint32 udtType = 0x6d657461; // The udt type of test files could be 'meta' |
|
2531 T3GPUdtaLocation location = E3GPUdtaMoov; // The test files should not contain udta in audio trak |
|
2532 |
|
2533 // First read user data atom with empty buffer. It should return KErrOverflow |
|
2534 RBuf8 buffer; |
|
2535 CleanupClosePushL(buffer); |
|
2536 buffer.CreateL(0); |
|
2537 TInt err = aParse->GetUserDataAtom(udtType, location, buffer, index); |
|
2538 buffer.Close(); |
|
2539 CleanupStack::PopAndDestroy(&buffer); |
|
2540 |
|
2541 if (err != KErrOverflow) |
|
2542 { |
|
2543 ERR_PRINTF2(_L("GetUserDataAtom with empty buffer should return KErrOverflow, failed with err %d"), err); |
|
2544 User::Leave(err); |
|
2545 } |
|
2546 |
|
2547 err = CallUDTApi(aParse, udtType, index); // By default, the location is videoTrack |
|
2548 |
|
2549 if (err == KErrNotFound || err == KErrNone) |
|
2550 { |
|
2551 err = CallUDTApi(aParse, udtType, index, location); |
|
2552 |
|
2553 if (err == KErrNotFound || err == KErrNone) |
|
2554 { |
|
2555 location = E3GPUdtaAudioTrak; |
|
2556 err = CallUDTApi(aParse, udtType, index, location); |
|
2557 } |
|
2558 } |
|
2559 |
|
2560 SetTestStepError(err); |
|
2561 |
|
2562 ParserCompleteL(aParse); |
|
2563 } |
|
2564 |
|
2565 // ----------------------------------------------------------------------------- |
|
2566 // Retrieve video frame dependencies |
|
2567 // ----------------------------------------------------------------------------- |
|
2568 // |
|
2569 C3GPLibParser_0037::C3GPLibParser_0037() |
|
2570 { |
|
2571 } |
|
2572 |
|
2573 TVerdict C3GPLibParser_0037::doTestStepL() |
|
2574 { |
|
2575 if(TestStepResult() == EPass) |
|
2576 { |
|
2577 C3GPParse* parser = C3GPParse::NewL(); |
|
2578 CleanupStack::PushL(parser); |
|
2579 |
|
2580 TRAPD(err, VideoDependencyL(parser)); |
|
2581 if (err != KErrNone) |
|
2582 { |
|
2583 SetTestStepResult(EFail); |
|
2584 } |
|
2585 |
|
2586 CleanupStack::PopAndDestroy(parser); |
|
2587 } |
|
2588 return TestStepResult(); |
|
2589 } |
|
2590 |
|
2591 void C3GPLibParser_0037::VideoDependencyL(C3GPParse* aParser) |
|
2592 { |
|
2593 // file mode |
|
2594 ParserOpenFileL(aParser); |
|
2595 |
|
2596 TUint num; |
|
2597 User::LeaveIfError(aParser->GetNumberOfVideoFrames(num)); |
|
2598 |
|
2599 TInt err = KErrNone; |
|
2600 T3GPFrameDependencies dependencies; |
|
2601 for (TInt i = 0; i < num; i++) |
|
2602 { |
|
2603 err = aParser->GetVideoFrameDependencies(dependencies); |
|
2604 if (err != KErrNone) |
|
2605 { |
|
2606 ERR_PRINTF2(_L("GetVideoFrameDependencies failed with %d"), err); |
|
2607 SetTestStepError(err); |
|
2608 break; |
|
2609 } |
|
2610 } |
|
2611 ParserCompleteL(aParser); |
|
2612 } |
|
2613 |
|
2614 // ----------------------------------------------------------------------------- |
|
2615 // Get Video Frame Properties |
|
2616 // ----------------------------------------------------------------------------- |
|
2617 // |
|
2618 C3GPLibParser_0038::C3GPLibParser_0038() |
|
2619 { |
|
2620 } |
|
2621 |
|
2622 TVerdict C3GPLibParser_0038::doTestStepL() |
|
2623 { |
|
2624 if(TestStepResult() == EPass) |
|
2625 { |
|
2626 C3GPParse* parser = C3GPParse::NewL(); |
|
2627 CleanupStack::PushL(parser); |
|
2628 |
|
2629 TRAPD(err, VideoInfoL(parser)); |
|
2630 if (err != KErrNone) |
|
2631 { |
|
2632 SetTestStepResult(EFail); |
|
2633 } |
|
2634 |
|
2635 CleanupStack::PopAndDestroy(parser); |
|
2636 } |
|
2637 return TestStepResult(); |
|
2638 } |
|
2639 |
|
2640 void C3GPLibParser_0038::VideoInfoL(C3GPParse* aParser) |
|
2641 { |
|
2642 // file mode |
|
2643 ParserOpenFileL(aParser); |
|
2644 |
|
2645 TUint num; |
|
2646 TUint timeStampInMs = 0; |
|
2647 TUint timeStampInTimescale = 0; |
|
2648 TUint frameIndex; |
|
2649 TBool keyFrame; |
|
2650 User::LeaveIfError(aParser->GetNumberOfVideoFrames(num)); |
|
2651 User::LeaveIfError(aParser->GetVideoSampleEntryIndex(frameIndex)); |
|
2652 |
|
2653 TInt err = KErrNone; |
|
2654 for (TInt i = 0; i < num; i++) |
|
2655 { |
|
2656 err = aParser->GetVideoFrameKeyType(i, keyFrame); |
|
2657 User::LeaveIfError(CheckError(err, KErrNone, _L("GetVideoFrameKeyType()"))); |
|
2658 |
|
2659 err = aParser->GetVideoFrameStartTime(i, timeStampInMs, timeStampInTimescale); |
|
2660 User::LeaveIfError(CheckError(err, KErrNone, _L("GetVideoFrameStartTime()"))); |
|
2661 } |
|
2662 |
|
2663 TUint startIndex = 0; |
|
2664 RArray<T3GPFrameInfoParameters> array; |
|
2665 CleanupClosePushL(array); |
|
2666 |
|
2667 err = aParser->GetVideoFrameProperties(startIndex, num, array); |
|
2668 User::LeaveIfError(CheckError(err, KErrNone, _L("GetVideoFrameProperties"))); |
|
2669 if (!ShouldRunOOMTest()) |
|
2670 { |
|
2671 INFO_PRINTF1(_L("aParser->GetVideoFrameProperties passed.")); |
|
2672 } |
|
2673 |
|
2674 RArray<T3GPFrameInfoParameters> array1; |
|
2675 CleanupClosePushL(array1); |
|
2676 |
|
2677 // Filled in array with some data, say array with size 3 |
|
2678 TInt arraySize = 3; |
|
2679 T3GPFrameInfoParameters fip; |
|
2680 for (TInt i = 0; i < arraySize; i++) |
|
2681 { |
|
2682 fip.iSize = i; |
|
2683 fip.iStartTime = 1000; |
|
2684 fip.iIsRandomAccessPoint = ETrue; |
|
2685 array1.AppendL(fip); |
|
2686 } |
|
2687 |
|
2688 if (!ShouldRunOOMTest()) |
|
2689 { |
|
2690 INFO_PRINTF1(_L("Filled in array with some junk data and call aParser->GetVideoFrameProperties() ago.")); |
|
2691 } |
|
2692 |
|
2693 err = aParser->GetVideoFrameProperties(startIndex, num, array1); |
|
2694 User::LeaveIfError(CheckError(err, KErrNone, _L("GetVideoFrameProperties"))); |
|
2695 |
|
2696 // Check two arrays are the same |
|
2697 if (array.Count() != array1.Count()) |
|
2698 { |
|
2699 ERR_PRINTF3(_L("array1.Count() is %d; expected array.Count() is %d."), array1.Count(), array.Count()); |
|
2700 User::Leave(KErrGeneral); |
|
2701 } |
|
2702 for (TInt j = 0; j < array.Count(); j++) |
|
2703 { |
|
2704 if (array1[j].iSize != array[j].iSize || array1[j].iStartTime != array1[j].iStartTime || |
|
2705 array1[j].iIsRandomAccessPoint != array1[j].iIsRandomAccessPoint) |
|
2706 { |
|
2707 ERR_PRINTF1(_L("Two array are not the same.")); |
|
2708 User::Leave(KErrGeneral); |
|
2709 } |
|
2710 } |
|
2711 |
|
2712 if (!ShouldRunOOMTest()) |
|
2713 { |
|
2714 INFO_PRINTF1(_L("Two arrays are the same.")); |
|
2715 } |
|
2716 CleanupStack::PopAndDestroy(&array1); |
|
2717 CleanupStack::PopAndDestroy(&array); |
|
2718 |
|
2719 ParserCompleteL(aParser); |
|
2720 } |
|
2721 |
|
2722 // ----------------------------------------------------------------------------- |
|
2723 // Read a audio and a video frame into a buffer of filled with junk content and |
|
2724 // ensure the buffer gets properly reset when retrieve video / audio frame data. |
|
2725 // ----------------------------------------------------------------------------- |
|
2726 // |
|
2727 C3GPLibParser_0039::C3GPLibParser_0039() |
|
2728 { |
|
2729 } |
|
2730 |
|
2731 TVerdict C3GPLibParser_0039::doTestStepL() |
|
2732 { |
|
2733 if(TestStepResult() == EPass) |
|
2734 { |
|
2735 C3GPParse* parser = C3GPParse::NewL(); |
|
2736 CleanupStack::PushL(parser); |
|
2737 |
|
2738 TRAPD(err, AudioAndVideoFrameL(parser)); |
|
2739 if (err != KErrNone) |
|
2740 { |
|
2741 SetTestStepResult(EFail); |
|
2742 } |
|
2743 |
|
2744 CleanupStack::PopAndDestroy(parser); |
|
2745 } |
|
2746 return TestStepResult(); |
|
2747 } |
|
2748 |
|
2749 void C3GPLibParser_0039::AudioAndVideoFrameL(C3GPParse* aParser) |
|
2750 { |
|
2751 // file mode |
|
2752 ParserOpenFileL(aParser); |
|
2753 |
|
2754 TUint size; |
|
2755 TInt err = aParser->GetVideoFrameSize(size); |
|
2756 User::LeaveIfError(CheckError(err, KErrNone, _L("GetVideoFrameSize"))); |
|
2757 |
|
2758 RBuf8 buffer; |
|
2759 CleanupClosePushL(buffer); |
|
2760 buffer.CreateL(size + 15); // Create a buffer bigger than the size returned by GetVideoFrameSize |
|
2761 // Filled in junk data into the buffer |
|
2762 TChar c = 'a'; |
|
2763 buffer.AppendFill(c, (size + 15)); |
|
2764 |
|
2765 TBool keyFrame; |
|
2766 TUint timeStampInMs; |
|
2767 TUint timeStampInTimescale; |
|
2768 err = aParser->ReadVideoFrame(buffer, keyFrame, timeStampInMs, timeStampInTimescale); |
|
2769 User::LeaveIfError(CheckError(err, KErrNone, _L("ReadVideoFrame"))); |
|
2770 // Check the buffer size is the same as size returned by GetVideoFrameSize |
|
2771 if (buffer.Length() != size) |
|
2772 { |
|
2773 ERR_PRINTF3(_L("buffer size is %d; expected size is %d."), buffer.Length(), size); |
|
2774 User::Leave(KErrGeneral); |
|
2775 } |
|
2776 CleanupStack::PopAndDestroy(&buffer); |
|
2777 |
|
2778 err = aParser->GetAudioFramesSize(size); |
|
2779 User::LeaveIfError(CheckError(err, KErrNone, _L("GetAudioFramesSize"))); |
|
2780 |
|
2781 RBuf8 bufferBig; |
|
2782 CleanupClosePushL(bufferBig); |
|
2783 bufferBig.CreateL(size + 10); // Create a buffer bigger than the size returned by GetVideoFrameSize |
|
2784 // Filled in junk data into the buffer |
|
2785 bufferBig.AppendFill(c, (size + 10)); |
|
2786 |
|
2787 TInt returnedFrames; |
|
2788 err = aParser->ReadAudioFrames(bufferBig, returnedFrames, timeStampInMs, timeStampInTimescale); |
|
2789 User::LeaveIfError(CheckError(err, KErrNone, _L("ReadAudioFrames"))); |
|
2790 // Check the buffer size is the same as size returned by GetVideoFrameSize |
|
2791 if (bufferBig.Length() != size) |
|
2792 { |
|
2793 ERR_PRINTF3(_L("buffer size is %d; expected size is %d."), buffer.Length(), size); |
|
2794 User::Leave(KErrGeneral); |
|
2795 } |
|
2796 |
|
2797 CleanupStack::PopAndDestroy(&bufferBig); |
|
2798 |
|
2799 ParserCompleteL(aParser); |
|
2800 } |
|
2801 |
|
2802 // ----------------------------------------------------------------------------- |
|
2803 // Multiple parser working simultaneously. |
|
2804 // ----------------------------------------------------------------------------- |
|
2805 // |
|
2806 C3GPLibParser_0041::C3GPLibParser_0041() |
|
2807 { |
|
2808 } |
|
2809 |
|
2810 TVerdict C3GPLibParser_0041::doTestStepPreambleL() |
|
2811 { |
|
2812 // Add the names of the new files to the following file list array. |
|
2813 TInt numOfFiles = 2; // This is the array number. Should be the same as the number of the array. |
|
2814 const TText* SelectedFiles[] = |
|
2815 { |
|
2816 _S("mpeg4-aac.3gp"), // File with both audio and video |
|
2817 _S("arm-nb-acelp-only.3gp") // File with audio only |
|
2818 }; |
|
2819 |
|
2820 for (TInt index = 0; index < numOfFiles; index++) |
|
2821 { |
|
2822 // Create a zero terminated version of the file name |
|
2823 TFileName inputFile(K3GPLibTestFilePath); |
|
2824 inputFile += TPtrC(SelectedFiles[index]); |
|
2825 inputFile.ZeroTerminate(); |
|
2826 |
|
2827 if (index == 0) |
|
2828 { |
|
2829 User::LeaveIfError(iInputFile1.Create(inputFile.Length() + 1)); |
|
2830 iInputFile1.Copy(inputFile); |
|
2831 } |
|
2832 else |
|
2833 { |
|
2834 User::LeaveIfError(iInputFile2.Create(inputFile.Length() + 1)); |
|
2835 iInputFile2.Copy(inputFile); |
|
2836 } |
|
2837 } |
|
2838 return TestStepResult(); |
|
2839 } |
|
2840 |
|
2841 TVerdict C3GPLibParser_0041::doTestStepPostambleL() |
|
2842 { |
|
2843 iInputFile1.Close(); |
|
2844 iInputFile2.Close(); |
|
2845 return TestStepResult(); |
|
2846 } |
|
2847 |
|
2848 TVerdict C3GPLibParser_0041::doTestStepL() |
|
2849 { |
|
2850 if(TestStepResult() == EPass) |
|
2851 { |
|
2852 C3GPParse* parser1 = C3GPParse::NewL(); |
|
2853 CleanupStack::PushL(parser1); |
|
2854 |
|
2855 TInt err = parser1->Open(iInputFile1); |
|
2856 User::LeaveIfError(CheckError(err, KErrNone, _L("aParser1->Open"))); |
|
2857 |
|
2858 C3GPParse* parser2 = C3GPParse::NewL(); |
|
2859 CleanupStack::PushL(parser2); |
|
2860 |
|
2861 err = parser2->Open(iInputFile1); |
|
2862 User::LeaveIfError(CheckError(err, KErrNone, _L("aParser2->Open"))); |
|
2863 |
|
2864 C3GPParse* parser3 = C3GPParse::NewL(); |
|
2865 CleanupStack::PushL(parser3); |
|
2866 |
|
2867 err = parser3->Open(iInputFile2); |
|
2868 User::LeaveIfError(CheckError(err, KErrNone, _L("aParser3->Open"))); |
|
2869 |
|
2870 TRAP(err, MultipleParserL(parser1, parser2, parser3)); |
|
2871 if (err != KErrNone) |
|
2872 { |
|
2873 SetTestStepResult(EFail); |
|
2874 } |
|
2875 |
|
2876 ParserCompleteL(parser1); |
|
2877 ParserCompleteL(parser2); |
|
2878 ParserCompleteL(parser3); |
|
2879 |
|
2880 CleanupStack::PopAndDestroy(parser3); |
|
2881 CleanupStack::PopAndDestroy(parser2); |
|
2882 CleanupStack::PopAndDestroy(parser1); |
|
2883 } |
|
2884 return TestStepResult(); |
|
2885 } |
|
2886 |
|
2887 void C3GPLibParser_0041::MultipleParserL(C3GPParse* aParser1, C3GPParse* aParser2, C3GPParse* aParser3) |
|
2888 { |
|
2889 TInt err = ReadAudioVideoFrame(aParser1); |
|
2890 User::LeaveIfError(CheckError(err, KErrNotFound, _L("ReadAudioVideoFrame(aParser1)"))); |
|
2891 |
|
2892 // Read one video frame with parser2 |
|
2893 err = ReadAudioVideoFrame(aParser2, EFalse, EFalse); |
|
2894 User::LeaveIfError(CheckError(err, KErrNone, _L("ReadAudioVideoFrame(aParser2)"))); |
|
2895 |
|
2896 // Read video properties with parser3. Expected failed with KErrNotSupported |
|
2897 T3GPVideoType videoType; |
|
2898 TUint length; |
|
2899 TReal frameRate; |
|
2900 TUint avgBitRate; |
|
2901 TSize videoSize; |
|
2902 TUint timeScale; |
|
2903 |
|
2904 err = aParser3->GetVideoProperties(videoType, length, frameRate, avgBitRate, videoSize, timeScale); |
|
2905 User::LeaveIfError(CheckError(err, KErrNotSupported, _L("aParser3->GetVideoProperties"))); |
|
2906 } |
|
2907 |
|
2908 // ----------------------------------------------------------------------------- |
|
2909 // Seek position in buffer mode |
|
2910 // ----------------------------------------------------------------------------- |
|
2911 // |
|
2912 C3GPLibParser_0043::C3GPLibParser_0043() |
|
2913 { |
|
2914 } |
|
2915 |
|
2916 TVerdict C3GPLibParser_0043::doTestStepL() |
|
2917 { |
|
2918 if(TestStepResult() == EPass) |
|
2919 { |
|
2920 C3GPParse* parser = C3GPParse::NewL(); |
|
2921 CleanupStack::PushL(parser); |
|
2922 |
|
2923 TRAPD(err, SeekBufferModeL(parser)); |
|
2924 if (err != KErrNone) |
|
2925 { |
|
2926 SetTestStepResult(EFail); |
|
2927 } |
|
2928 |
|
2929 CleanupStack::PopAndDestroy(parser); |
|
2930 } |
|
2931 return TestStepResult(); |
|
2932 } |
|
2933 |
|
2934 void C3GPLibParser_0043::SeekBufferModeL(C3GPParse* aParser) |
|
2935 { |
|
2936 // buffer mode |
|
2937 ParserOpenL(aParser); |
|
2938 FileOpenL(); |
|
2939 |
|
2940 // Insert buffer data into the library |
|
2941 TInt pos = 0; |
|
2942 TInt bufferSize = KBufferSize; |
|
2943 InsertDataL(aParser, iSourceFile, bufferSize, pos); |
|
2944 |
|
2945 TUint audioPos; |
|
2946 TUint videoPos; |
|
2947 TUint timeStampInMs = 0; |
|
2948 |
|
2949 // Seek the position |
|
2950 TInt err = aParser->Seek(timeStampInMs, EFalse, audioPos, videoPos); |
|
2951 while (err == KErr3gpLibMoreDataRequired) |
|
2952 { |
|
2953 pos = pos + bufferSize; |
|
2954 InsertDataL(aParser, iSourceFile, bufferSize, pos); |
|
2955 err = aParser->Seek(timeStampInMs, EFalse, audioPos, videoPos); |
|
2956 } |
|
2957 |
|
2958 if (err != KErrNone) |
|
2959 { |
|
2960 SetTestStepError(err); |
|
2961 } |
|
2962 ParserCompleteL(aParser); |
|
2963 FileClose(); |
|
2964 } |
|
2965 |
|
2966 // ----------------------------------------------------------------------------- |
|
2967 // Test C3GPParse with large file (>2GB) |
|
2968 // ----------------------------------------------------------------------------- |
|
2969 // |
|
2970 C3GPLibParser_0045::C3GPLibParser_0045() |
|
2971 { |
|
2972 } |
|
2973 |
|
2974 TVerdict C3GPLibParser_0045::doTestStepPreambleL() |
|
2975 { |
|
2976 C3GPLib_AsyncObserver::doTestStepPreambleL(); |
|
2977 if (TestStepResult() == EPass) |
|
2978 { |
|
2979 iScheduler = new (ELeave) CActiveScheduler; |
|
2980 CActiveScheduler::Install(iScheduler); |
|
2981 } |
|
2982 return TestStepResult(); |
|
2983 } |
|
2984 |
|
2985 TVerdict C3GPLibParser_0045::doTestStepPostambleL() |
|
2986 { |
|
2987 C3GPLib_AsyncObserver::doTestStepPostambleL(); |
|
2988 if( iScheduler ) |
|
2989 { |
|
2990 INFO_PRINTF1(_L("delete iScheduler")); |
|
2991 CActiveScheduler::Install(NULL); |
|
2992 delete iScheduler; |
|
2993 iScheduler = NULL; |
|
2994 } |
|
2995 |
|
2996 return TestStepResult(); |
|
2997 } |
|
2998 |
|
2999 TVerdict C3GPLibParser_0045::doTestStepL() |
|
3000 { |
|
3001 if(TestStepResult() == EPass) |
|
3002 { |
|
3003 C3GPParse* parser = C3GPParse::NewL(); |
|
3004 CleanupStack::PushL(parser); |
|
3005 |
|
3006 TRAPD(err, TestParserWithLargeFileL(parser)); |
|
3007 if (err != KErrNone) |
|
3008 { |
|
3009 SetTestStepResult(EFail); |
|
3010 } |
|
3011 |
|
3012 CleanupStack::PopAndDestroy(parser); |
|
3013 } |
|
3014 return TestStepResult(); |
|
3015 } |
|
3016 |
|
3017 void C3GPLibParser_0045::TestParserWithLargeFileL(C3GPParse* aParser) |
|
3018 { |
|
3019 INFO_PRINTF1(_L("Test Parser With Large File (>2GB)")); |
|
3020 INFO_PRINTF1(_L("Open and complete parser with 64 bit file handle")); |
|
3021 |
|
3022 ParserOpenFileHandle64L(aParser); |
|
3023 ParserCompleteHandle64L(aParser); |
|
3024 |
|
3025 ParserOpenFileHandle64L(aParser, EFileRead | EFileShareReadersOnly); |
|
3026 ParserCompleteHandle64L(aParser); |
|
3027 |
|
3028 ParserOpenFileHandle64L(aParser, EFileShareReadersOrWriters | EFileWrite); |
|
3029 ParserCompleteHandle64L(aParser); |
|
3030 |
|
3031 ParserOpenFileHandle64L(aParser, EFileShareReadersOrWriters | EFileRead); |
|
3032 ParserCompleteHandle64L(aParser); |
|
3033 |
|
3034 ParserOpenFileHandle64L(aParser, EFileShareAny | EFileWrite); |
|
3035 ParserCompleteHandle64L(aParser); |
|
3036 |
|
3037 ParserOpenFileHandle64L(aParser, EFileShareAny | EFileRead); |
|
3038 ParserCompleteHandle64L(aParser); |
|
3039 |
|
3040 INFO_PRINTF1(_L("Test parser with 64 bit file handle")); |
|
3041 |
|
3042 // Read audio/video attributes |
|
3043 ParserOpenFileHandle64L(aParser); |
|
3044 DoGetVideoAudioAttributesL(aParser); |
|
3045 ParserCompleteHandle64L(aParser); |
|
3046 |
|
3047 // Read audio/video frames |
|
3048 ParserOpenFileHandle64L(aParser); |
|
3049 User::LeaveIfError(DoReadFrame(aParser)); |
|
3050 ParserCompleteHandle64L(aParser); |
|
3051 |
|
3052 // Asynchronous Read of audio/video frames |
|
3053 ParserOpenFileHandle64L(aParser); |
|
3054 User::LeaveIfError(DoReadFrameAsync(aParser)); |
|
3055 if (!ShouldRunOOMTest()) |
|
3056 { |
|
3057 INFO_PRINTF1(_L("C3GPLibParser_0045::ReadFrameAsyncL() using 64 bit file handle")); |
|
3058 } |
|
3059 ParserCompleteHandle64L(aParser); |
|
3060 |
|
3061 // Seek positions after any keyframe and immediately after a non-key frame |
|
3062 ParserOpenFileHandle64L(aParser); |
|
3063 DoSeekTestL(aParser); |
|
3064 ParserCompleteHandle64L(aParser); |
|
3065 |
|
3066 INFO_PRINTF1(_L("Test parser in File path")); |
|
3067 |
|
3068 // Read audio/video attributes |
|
3069 ParserOpenFileL(aParser); |
|
3070 DoGetVideoAudioAttributesL(aParser); |
|
3071 ParserCompleteL(aParser); |
|
3072 |
|
3073 // Read audio/video frames |
|
3074 ParserOpenFileL(aParser); |
|
3075 User::LeaveIfError(DoReadFrame(aParser)); |
|
3076 ParserCompleteL(aParser); |
|
3077 |
|
3078 // Asynchronous Read of audio/video frames |
|
3079 ParserOpenFileL(aParser); |
|
3080 User::LeaveIfError(DoReadFrameAsync(aParser)); |
|
3081 if (!ShouldRunOOMTest()) |
|
3082 { |
|
3083 INFO_PRINTF1(_L("C3GPLibParser_0014::ReadFrameAsyncL()")); |
|
3084 } |
|
3085 ParserCompleteL(aParser); |
|
3086 |
|
3087 ParserOpenFileL(aParser); |
|
3088 User::LeaveIfError(DoReadFrameAsync(aParser, ETrue)); |
|
3089 if (!ShouldRunOOMTest()) |
|
3090 { |
|
3091 INFO_PRINTF1(_L("C3GPLibParser_0014::ReadFrameAsyncL(), then cancel the read")); |
|
3092 } |
|
3093 ParserCompleteL(aParser); |
|
3094 |
|
3095 INFO_PRINTF1(_L("Test parser in CAF")); |
|
3096 |
|
3097 // Read audio/video attributes |
|
3098 ParserOpenCafLC(aParser); |
|
3099 DoGetVideoAudioAttributesL(aParser); |
|
3100 ParserCompleteCafL(aParser); |
|
3101 |
|
3102 // Read audio/video frames |
|
3103 ParserOpenCafLC(aParser); |
|
3104 User::LeaveIfError(DoReadFrame(aParser)); |
|
3105 ParserCompleteCafL(aParser); |
|
3106 |
|
3107 // Asynchronous Read of audio/video frames |
|
3108 ParserOpenCafLC(aParser); |
|
3109 User::LeaveIfError(DoReadFrameAsync(aParser)); |
|
3110 if (!ShouldRunOOMTest()) |
|
3111 { |
|
3112 INFO_PRINTF1(_L("C3GPLibParser_0014::ReadFrameAsyncL() using CAF")); |
|
3113 } |
|
3114 ParserCompleteCafL(aParser); |
|
3115 } |
|
3116 |
|
3117 TInt C3GPLibParser_0045::DoReadFrameAsync(C3GPParse* aParser, TBool aCancel) |
|
3118 { |
|
3119 TInt err = KErrNone; |
|
3120 |
|
3121 if (!aCancel) |
|
3122 { |
|
3123 err = ReadAudioVideoFrameAsync(aParser, ETrue); |
|
3124 if (err == KErrNone) |
|
3125 { |
|
3126 err = ReadAudioVideoFrameAsync(aParser, EFalse); |
|
3127 } |
|
3128 } |
|
3129 else |
|
3130 { |
|
3131 err = ReadAudioVideoFrameAsync(aParser, EFalse, ETrue); |
|
3132 } |
|
3133 |
|
3134 return err; |
|
3135 } |
|
3136 |
|
3137 // ----------------------------------------------------------------------------- |
|
3138 // Parse video & audio frames from >2GB file synchronously in buffer mode |
|
3139 // ----------------------------------------------------------------------------- |
|
3140 // |
|
3141 C3GPLibParser_0047::C3GPLibParser_0047() |
|
3142 { |
|
3143 } |
|
3144 |
|
3145 TVerdict C3GPLibParser_0047::doTestStepL() |
|
3146 { |
|
3147 if(TestStepResult() == EPass) |
|
3148 { |
|
3149 C3GPParse* parser = C3GPParse::NewL(); |
|
3150 CleanupStack::PushL(parser); |
|
3151 |
|
3152 TRAPD(err, ReadFrameL(parser)); |
|
3153 if (err != KErrNone) |
|
3154 { |
|
3155 SetTestStepResult(EFail); |
|
3156 } |
|
3157 |
|
3158 CleanupStack::PopAndDestroy(parser); |
|
3159 } |
|
3160 return TestStepResult(); |
|
3161 } |
|
3162 |
|
3163 void C3GPLibParser_0047::ReadFrameL(C3GPParse* aParser) |
|
3164 { |
|
3165 FileOpen64L(); |
|
3166 ReadFrameBufferModeL(aParser); |
|
3167 FileClose64(); |
|
3168 } |
|
3169 |
|
3170 // ----------------------------------------------------------------------------- |
|
3171 // Retrieve User Data Atoms with Multiple atoms |
|
3172 // ----------------------------------------------------------------------------- |
|
3173 // |
|
3174 _LIT(KAtomFileNamePrefix, "AtomFile"); |
|
3175 |
|
3176 C3GPUserDataAtomRetrieval::C3GPUserDataAtomRetrieval() |
|
3177 { |
|
3178 } |
|
3179 |
|
3180 TVerdict C3GPUserDataAtomRetrieval::doTestStepL() |
|
3181 { |
|
3182 // ensure test step error & result reset before each test |
|
3183 if (TestStepResult() != EPass) |
|
3184 { |
|
3185 return TestStepResult(); |
|
3186 } |
|
3187 SetTestStepError(KErrNone); |
|
3188 |
|
3189 C3GPParse* parser = C3GPParse::NewL(); |
|
3190 CleanupStack::PushL(parser); |
|
3191 |
|
3192 if (iLargeFile) |
|
3193 { |
|
3194 User::LeaveIfError(parser->Open(iInputFile64)); |
|
3195 } |
|
3196 else |
|
3197 { |
|
3198 User::LeaveIfError(parser->Open(iInputFile)); |
|
3199 } |
|
3200 |
|
3201 TBool keepLooking = ETrue; |
|
3202 TInt atomFound = 0; |
|
3203 TInt atomSize = 0; |
|
3204 TUint atomIndex = 0; |
|
3205 TUint atomHighestIndex1 = 0; |
|
3206 TUint atomHighestIndex2 = 0; |
|
3207 TInt err = KErrNone; |
|
3208 RFile atomFile; |
|
3209 RBuf8 atomContent; |
|
3210 RBuf8 fileContent; |
|
3211 CleanupClosePushL(fileContent); |
|
3212 CleanupClosePushL(atomFile); |
|
3213 CleanupClosePushL(atomContent); |
|
3214 |
|
3215 while(keepLooking && err == KErrNone) |
|
3216 { |
|
3217 TInt atomIndexInput = atomIndex; |
|
3218 err = parser->GetUserDataAtomSize(iAtomType, iAtomLocation, atomIndex, atomSize); |
|
3219 if (err == KErrNone) |
|
3220 { |
|
3221 atomHighestIndex1 = atomIndex; |
|
3222 atomIndex = atomIndexInput; |
|
3223 atomContent.CreateL(atomSize); |
|
3224 |
|
3225 err = parser->GetUserDataAtom(iAtomType, iAtomLocation, atomContent, atomIndex); |
|
3226 if (err == KErrNone) |
|
3227 { |
|
3228 if (atomFound == 0) |
|
3229 { |
|
3230 // remember the highest atom index found during first run |
|
3231 atomHighestIndex2 = atomIndex; |
|
3232 if (atomHighestIndex1 != atomHighestIndex2) |
|
3233 { |
|
3234 if (!ShouldRunOOMTest()) |
|
3235 { |
|
3236 ERR_PRINTF1(_L("Highest Atom Index returned is different when calling GetUserDataAtomSize vs GetUserDataAtom")); |
|
3237 } |
|
3238 } |
|
3239 } |
|
3240 atomFound++; |
|
3241 |
|
3242 User::LeaveIfError(atomFile.Open(iFs, (*iAtomFileArray)[atomIndexInput], EFileRead | EFileStream)); |
|
3243 TInt fileSize = 0; |
|
3244 User::LeaveIfError(atomFile.Size(fileSize)); |
|
3245 if (atomContent.Size() != fileSize) |
|
3246 { |
|
3247 if (!ShouldRunOOMTest()) |
|
3248 { |
|
3249 ERR_PRINTF4(_L("Atom %d retrieved is of different size as expected. Expected=%d Retrieved=%d"), atomIndexInput, fileSize, atomContent.Size()); |
|
3250 } |
|
3251 SetTestStepResult(EFail); |
|
3252 keepLooking = EFalse; |
|
3253 } |
|
3254 else |
|
3255 { |
|
3256 fileContent.CreateL(fileSize); |
|
3257 User::LeaveIfError(atomFile.Read(fileContent)); |
|
3258 if (fileContent != atomContent) |
|
3259 { |
|
3260 if (!ShouldRunOOMTest()) |
|
3261 { |
|
3262 ERR_PRINTF4(_L("Atom %d retrieved is of different content. Expected=%S Retrieved=%S"), atomIndexInput, &fileContent, &atomContent); |
|
3263 } |
|
3264 SetTestStepResult(EFail); |
|
3265 keepLooking = EFalse; |
|
3266 } |
|
3267 else |
|
3268 { |
|
3269 if (atomIndex != atomHighestIndex2) |
|
3270 { |
|
3271 // seems like there's an error occurred, as the highest index for this atom |
|
3272 // type should stay the same throughout |
|
3273 keepLooking = EFalse; |
|
3274 if (!ShouldRunOOMTest()) |
|
3275 { |
|
3276 ERR_PRINTF3(_L("Previous highest atom index is %d but now it is %d. Data inconsistency."), atomHighestIndex2, atomIndex); |
|
3277 } |
|
3278 SetTestStepResult(EFail); |
|
3279 } |
|
3280 else |
|
3281 { |
|
3282 // look for the next atom of the same type now |
|
3283 atomIndex = atomIndexInput + 1; |
|
3284 } |
|
3285 } |
|
3286 fileContent.Close(); |
|
3287 } |
|
3288 atomFile.Close(); |
|
3289 } |
|
3290 else |
|
3291 { |
|
3292 if (!ShouldRunOOMTest()) |
|
3293 { |
|
3294 ERR_PRINTF4(_L("Fail to get user atom: index = %d, location = %d, type = %d"), atomIndex, iAtomLocation, iAtomType); |
|
3295 } |
|
3296 User::Leave(err); |
|
3297 } |
|
3298 |
|
3299 atomContent.Close(); |
|
3300 } |
|
3301 } |
|
3302 if (TestStepResult() == EPass && atomFound != iExpectedNumAtom && atomFound == (atomHighestIndex2 + 1)) |
|
3303 { |
|
3304 if (!ShouldRunOOMTest()) |
|
3305 { |
|
3306 ERR_PRINTF3(_L("Number of atoms found (%d) does not match expected # of atoms (%d)."), atomFound, iExpectedNumAtom); |
|
3307 } |
|
3308 SetTestStepResult(EFail); |
|
3309 } |
|
3310 |
|
3311 CleanupStack::PopAndDestroy(&atomContent); |
|
3312 CleanupStack::PopAndDestroy(&atomFile); |
|
3313 CleanupStack::PopAndDestroy(&fileContent); |
|
3314 |
|
3315 parser->Complete(); |
|
3316 |
|
3317 CleanupStack::PopAndDestroy(parser); |
|
3318 return TestStepResult(); |
|
3319 } |
|
3320 |
|
3321 TVerdict C3GPUserDataAtomRetrieval::doTestStepPreambleL() |
|
3322 { |
|
3323 SetTestStepResult(ETestSuiteError); |
|
3324 |
|
3325 #ifdef __WINSCW__ |
|
3326 _LIT(KFileToParse, "FileToParseEmu"); |
|
3327 #else |
|
3328 _LIT(KFileToParse, "FileToParseHw"); |
|
3329 #endif |
|
3330 |
|
3331 TPtrC inputFilename; |
|
3332 if (!GetStringFromConfig(ConfigSection(), KFileToParse, inputFilename)) |
|
3333 { |
|
3334 // file need to be specified |
|
3335 ERR_PRINTF1(_L("Specify the file to be parsed.")); |
|
3336 return TestStepResult(); |
|
3337 } |
|
3338 |
|
3339 if (!GetBoolFromConfig(ConfigSection(), _L("largeFile"), iLargeFile)) |
|
3340 { |
|
3341 ERR_PRINTF1(_L("Specify whether the file is larger than 2GB.")); |
|
3342 return TestStepResult(); |
|
3343 } |
|
3344 |
|
3345 User::LeaveIfError(iFs.Connect()); |
|
3346 if (iLargeFile) |
|
3347 { |
|
3348 User::LeaveIfError(iInputFile64.Open(iFs, inputFilename, EFileRead | EFileStream | EFileShareReadersOnly)); |
|
3349 } |
|
3350 else |
|
3351 { |
|
3352 User::LeaveIfError(iInputFile.Open(iFs, inputFilename, EFileRead | EFileStream | EFileShareReadersOnly)); |
|
3353 } |
|
3354 |
|
3355 if (!GetIntFromConfig(ConfigSection(), _L("ExpectedNumOfAtom"), iExpectedNumAtom)) |
|
3356 { |
|
3357 // Number of expected number of atoms needs to be specified |
|
3358 ERR_PRINTF1(_L("Specify the number of atoms to be expected.")); |
|
3359 return TestStepResult(); |
|
3360 } |
|
3361 |
|
3362 iAtomFileArray = new CDesCArrayFlat(4); |
|
3363 TInt temp; |
|
3364 if (!GetIntFromConfig(ConfigSection(), _L("AtomType"), temp)) |
|
3365 { |
|
3366 // atom type to retrieve needs to be specified |
|
3367 ERR_PRINTF1(_L("Specify the atoms type to be retrieved.")); |
|
3368 return TestStepResult(); |
|
3369 } |
|
3370 else |
|
3371 { |
|
3372 iAtomType = (TUint32) temp; |
|
3373 } |
|
3374 |
|
3375 if (!GetIntFromConfig(ConfigSection(), _L("AtomLocation"), temp)) |
|
3376 { |
|
3377 // atom location to retrieve needs to be specified |
|
3378 ERR_PRINTF1(_L("Specify the atoms location for the atoms to be retrieved.")); |
|
3379 return TestStepResult(); |
|
3380 } |
|
3381 else |
|
3382 { |
|
3383 iAtomLocation = (T3GPUdtaLocation) temp; |
|
3384 } |
|
3385 |
|
3386 if (iExpectedNumAtom > 0) |
|
3387 { |
|
3388 TBuf<50> keyName; |
|
3389 TPtrC fileName; |
|
3390 for (TInt i = 1; i <= iExpectedNumAtom; i++) |
|
3391 { |
|
3392 keyName.Zero(); |
|
3393 keyName.AppendFormat(_L("%S%d"), &KAtomFileNamePrefix, i); |
|
3394 |
|
3395 if (!GetStringFromConfig(ConfigSection(), keyName, fileName)) |
|
3396 { |
|
3397 // atom content file needs to be specified |
|
3398 ERR_PRINTF1(_L("Specify the file name that contents the matching atom content.")); |
|
3399 return TestStepResult(); |
|
3400 } |
|
3401 |
|
3402 iAtomFileArray->AppendL(fileName); |
|
3403 } |
|
3404 } |
|
3405 |
|
3406 SetTestStepResult(EPass); |
|
3407 return TestStepResult(); |
|
3408 } |
|
3409 |
|
3410 TVerdict C3GPUserDataAtomRetrieval::doTestStepPostambleL() |
|
3411 { |
|
3412 if (iAtomFileArray) |
|
3413 { |
|
3414 iAtomFileArray->Reset(); |
|
3415 delete iAtomFileArray; |
|
3416 } |
|
3417 |
|
3418 if (iLargeFile) |
|
3419 { |
|
3420 iInputFile64.Close(); |
|
3421 } |
|
3422 else |
|
3423 { |
|
3424 iInputFile.Close(); |
|
3425 } |
|
3426 iFs.Close(); |
|
3427 |
|
3428 return TestStepResult(); |
|
3429 } |