|
1 /* |
|
2 * Copyright (c) 2002-2007 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: This class is used for playing video. |
|
15 * |
|
16 */ |
|
17 |
|
18 // INCLUDE FILES |
|
19 #include <mmf/server/mmffile.h> |
|
20 #include <jdebug.h> |
|
21 |
|
22 #include "cmmavideoplayer.h" |
|
23 #include "mmmadisplay.h" |
|
24 #include "cmmaeventsource.h" |
|
25 #include "cmmasurfacewindow.h" |
|
26 |
|
27 // CONSTANTS |
|
28 _LIT(KVideoControlName, "VideoControl"); |
|
29 |
|
30 CMMAVideoPlayer* CMMAVideoPlayer::NewLC( |
|
31 CMMAMMFResolver* aResolver) |
|
32 { |
|
33 CMMAVideoPlayer* self = |
|
34 new(ELeave) CMMAVideoPlayer(aResolver); |
|
35 CleanupStack::PushL(self); |
|
36 self->ConstructL(); |
|
37 return self; |
|
38 } |
|
39 |
|
40 CMMAVideoPlayer::~CMMAVideoPlayer() |
|
41 { |
|
42 DEBUG("MMA::CMMAVideoPlayer::~CMMAVideoPlayer"); |
|
43 |
|
44 // Window is not able to send any |
|
45 // callback requests to UI from now. |
|
46 if (iSurfaceWindow) |
|
47 { |
|
48 iSurfaceWindow->SetDisplay(NULL); |
|
49 } |
|
50 |
|
51 if (iDisplay && iDisplay->HasContainer()) |
|
52 { |
|
53 // Window will delete itself |
|
54 // after all pending events are processed |
|
55 // (lazy delete) |
|
56 iDisplay->UIGetCallback( |
|
57 *iSurfaceWindow, CMMASurfaceWindow::EDestroyWindow); |
|
58 } |
|
59 else |
|
60 { |
|
61 delete iSurfaceWindow; |
|
62 } |
|
63 |
|
64 if (iDisplay) |
|
65 { |
|
66 TRAPD(err, iDisplay->SetWindowL(NULL)); |
|
67 if (err != KErrNone) |
|
68 { |
|
69 __ASSERT_DEBUG(EFalse, User::Invariant()); |
|
70 } |
|
71 } |
|
72 |
|
73 delete iEmptySnapshotImage; |
|
74 delete iActiveSchedulerWait; |
|
75 } |
|
76 |
|
77 CMMAVideoPlayer::CMMAVideoPlayer( |
|
78 CMMAMMFResolver* aResolver): |
|
79 CMMAAudioPlayer(aResolver), |
|
80 iVideoControllerCustomCommands(iController), |
|
81 iVideoPlayControllerCustomCommands(iController), |
|
82 iVideoPlaySurfaceSupportCustomCommands(iController) |
|
83 { |
|
84 iMMASurface.iPrevSurfaceAvailable = EFalse; |
|
85 } |
|
86 |
|
87 void CMMAVideoPlayer::ConstructL() |
|
88 { |
|
89 CMMAAudioPlayer::ConstructL(); |
|
90 iActiveSchedulerWait = new(ELeave)CActiveSchedulerWait; |
|
91 } |
|
92 |
|
93 EXPORT_C void CMMAVideoPlayer::SetPlayerListenerObjectL(jobject aListenerObject, |
|
94 JNIEnv* aJni, |
|
95 MMMAEventPoster* aEventPoster) |
|
96 { |
|
97 CMMAPlayer::SetPlayerListenerObjectL(aListenerObject, |
|
98 aJni, |
|
99 aEventPoster); |
|
100 |
|
101 // this method must be called only ones |
|
102 __ASSERT_DEBUG(!iSurfaceWindow, User::Invariant()); |
|
103 |
|
104 // create window for videoplayer |
|
105 // event poster is always CMMAEventSource type. |
|
106 |
|
107 iSurfaceWindow = CMMASurfaceWindow::NewL( |
|
108 static_cast< CMMAEventSource* >(iEventPoster), |
|
109 this); |
|
110 } |
|
111 |
|
112 EXPORT_C void CMMAVideoPlayer::SetDisplayL(MMMADisplay* aDisplay) |
|
113 { |
|
114 // now it is ready to draw |
|
115 iDisplay = aDisplay; |
|
116 |
|
117 iSurfaceWindow->SetDisplay(aDisplay); |
|
118 |
|
119 iDisplay->SetWindowL(iSurfaceWindow); |
|
120 |
|
121 // if state < prefeteched then we dont know actual source size yet |
|
122 // and it will be set after prefetch |
|
123 if (iState >= EPrefetched) |
|
124 { |
|
125 SourceSizeChanged(); |
|
126 } |
|
127 } |
|
128 void CMMAVideoPlayer::RealizeL() |
|
129 { |
|
130 DEBUG("CMMAVideoPlayer::RealizeL"); |
|
131 // DataSource must have at least 1 stream or |
|
132 // we must have file to play |
|
133 if ((iSourceStreams.Count() == 0) && !iFileName) |
|
134 { |
|
135 User::Leave(KErrNotEnoughStreams); |
|
136 } |
|
137 |
|
138 // If file locator is used, then file is prefetched |
|
139 // in realized state so that FramePositioningControl |
|
140 // can acquire frame count in REALIZED state |
|
141 if (iFileName) |
|
142 { |
|
143 PrefetchFileL(); |
|
144 if (!iActiveSchedulerWait->IsStarted()) |
|
145 { |
|
146 iActiveSchedulerWait->Start(); |
|
147 } |
|
148 // If the player has not changed state during wait, |
|
149 // Then there is an error condition. |
|
150 if (iState != ERealized) |
|
151 { |
|
152 User::Leave(KErrNotSupported); |
|
153 } |
|
154 } |
|
155 else |
|
156 { |
|
157 CMMAPlayer::RealizeL(); |
|
158 } |
|
159 } |
|
160 |
|
161 void CMMAVideoPlayer::PrefetchL() |
|
162 { |
|
163 DEBUG("CMMAVideoPlayer::PrefetchL"); |
|
164 if (iFileName) |
|
165 { |
|
166 // File has already been prefetched when realizing |
|
167 |
|
168 // If initDisplayMode was called before prefetch, |
|
169 // then the display must notified about source size. |
|
170 if (iDisplay) |
|
171 { |
|
172 SourceSizeChanged(); |
|
173 } |
|
174 |
|
175 ChangeState(EPrefetched); |
|
176 PostActionCompleted(KErrNone); |
|
177 } |
|
178 else |
|
179 { |
|
180 // Using TDes -- load the whole video |
|
181 iSourceStreams[ 0 ]->ReadAllL(); |
|
182 } |
|
183 // CMMASourceStream will notify with ReadCompleted |
|
184 } |
|
185 |
|
186 EXPORT_C void CMMAVideoPlayer::ReadCompletedL(TInt aStatus, const TDesC8& aData) |
|
187 { |
|
188 DEBUG_INT("CMMAVideoPlayer::ReadCompletedL: status = %d", aStatus); |
|
189 if (aStatus < KErrNone) |
|
190 { |
|
191 PostActionCompleted(aStatus); |
|
192 } |
|
193 else |
|
194 { |
|
195 TRAPD(err, PrefetchDataL(aData)); |
|
196 if (err != KErrNone) |
|
197 { |
|
198 PostActionCompleted(err); |
|
199 } |
|
200 // action completed event will be delivered from handleEvent |
|
201 } |
|
202 } |
|
203 |
|
204 void CMMAVideoPlayer::HandleEvent(const TMMFEvent& aEvent) |
|
205 { |
|
206 DEBUG_INT("MMA:CMMAVideoPlayer::HandleEvent %d", aEvent.iEventType.iUid); |
|
207 |
|
208 // event KMMFEventCategoryPlaybackComplete is handled by both Video |
|
209 // and Audio players. first it should be handled by Video player |
|
210 if (aEvent.iEventType == KMMFEventCategoryPlaybackComplete) |
|
211 { |
|
212 iSurfaceWindow->RemoveSurface(); |
|
213 } |
|
214 |
|
215 // KNotCompleteVideoError can be notified when video is not complete |
|
216 // ( missing sound ) but still can be played. Because |
|
217 // CMMAAudioPlayer::HandleEvent fails with all negative error codes, |
|
218 // do not call it with KNotCompleteVideoError error when preparing. |
|
219 if ((aEvent.iErrorCode != KNotCompleteVideoError) || |
|
220 (aEvent.iEventType != KMMFEventCategoryVideoPrepareComplete)) |
|
221 { |
|
222 CMMAAudioPlayer::HandleEvent(aEvent); |
|
223 } |
|
224 |
|
225 if (aEvent.iEventType == KMMFEventCategoryVideoSurfaceCreated) |
|
226 { |
|
227 if (aEvent.iErrorCode == KErrNone) |
|
228 { |
|
229 TSurfaceId surfaceId; |
|
230 TRect cropRect; |
|
231 TVideoAspectRatio pixelAspectRatio; |
|
232 |
|
233 iVideoPlaySurfaceSupportCustomCommands.GetSurfaceParameters(surfaceId, |
|
234 cropRect, |
|
235 pixelAspectRatio); |
|
236 |
|
237 if (iMMASurface.iPrevSurfaceAvailable) |
|
238 { |
|
239 // free Surface |
|
240 TInt error = iVideoPlaySurfaceSupportCustomCommands.SurfaceRemoved(iMMASurface.iPrevSurfaceId); |
|
241 if (KErrNone != error) |
|
242 { |
|
243 DEBUG_INT("CMMAVideoPlayer::HandleEvent:SurfaceRemoved error, %d", aEvent.iErrorCode); |
|
244 } |
|
245 } |
|
246 iMMASurface.iPrevSurfaceId = surfaceId; |
|
247 iMMASurface.iPrevSurfaceAvailable = ETrue; |
|
248 |
|
249 iSurfaceWindow->SetSurfaceParameters(surfaceId, |
|
250 cropRect, |
|
251 pixelAspectRatio); |
|
252 |
|
253 DEBUG("CMMAVideoPlayer::HandleEvent: KMMFEventCategoryVideoSurfaceCreated, surface parameters set"); |
|
254 } |
|
255 else |
|
256 { |
|
257 DEBUG_INT("CMMAVideoPlayer::HandleEvent: error getting surface parameters, %d", aEvent.iErrorCode); |
|
258 } |
|
259 } |
|
260 else if (aEvent.iEventType == KMMFEventCategoryVideoSurfaceParametersChanged) |
|
261 { |
|
262 if (aEvent.iErrorCode == KErrNone) |
|
263 { |
|
264 TSurfaceId surfaceId; |
|
265 TRect cropRect; |
|
266 TVideoAspectRatio pixelAspectRatio; |
|
267 |
|
268 iVideoPlaySurfaceSupportCustomCommands.GetSurfaceParameters(surfaceId, |
|
269 cropRect, |
|
270 pixelAspectRatio); |
|
271 |
|
272 if (iMMASurface.iPrevSurfaceAvailable) |
|
273 { |
|
274 // free Surface |
|
275 TInt error = iVideoPlaySurfaceSupportCustomCommands.SurfaceRemoved(iMMASurface.iPrevSurfaceId); |
|
276 if (KErrNone != error) |
|
277 { |
|
278 DEBUG_INT("CMMAVideoPlayer::HandleEvent:SurfaceRemoved error, %d", aEvent.iErrorCode); |
|
279 } |
|
280 } |
|
281 iMMASurface.iPrevSurfaceAvailable = ETrue; |
|
282 iMMASurface.iPrevSurfaceId = surfaceId; |
|
283 |
|
284 iSurfaceWindow->SetChangedSurfaceParameters(surfaceId, |
|
285 cropRect, |
|
286 pixelAspectRatio); |
|
287 |
|
288 DEBUG("CMMAVideoPlayer::HandleEvent: KMMFEventCategoryVideoSurfaceParametersChanged"); |
|
289 } |
|
290 else |
|
291 { |
|
292 DEBUG_INT("CMMAVideoPlayer::HandleEvent: surface parameters changed error, %d", aEvent.iErrorCode); |
|
293 } |
|
294 } |
|
295 else if (aEvent.iEventType == KMMFEventCategoryVideoRemoveSurface) |
|
296 { |
|
297 if (aEvent.iErrorCode == KErrNone) |
|
298 { |
|
299 if (iMMASurface.iPrevSurfaceAvailable) |
|
300 { |
|
301 // free Surface |
|
302 TInt error = iVideoPlaySurfaceSupportCustomCommands.SurfaceRemoved(iMMASurface.iPrevSurfaceId); |
|
303 if (KErrNone != error) |
|
304 { |
|
305 DEBUG_INT("CMMAVideoPlayer::HandleEvent:SurfaceRemoved error, %d", aEvent.iErrorCode); |
|
306 } |
|
307 iMMASurface.iPrevSurfaceAvailable = EFalse; |
|
308 } |
|
309 } |
|
310 else |
|
311 { |
|
312 DEBUG_INT("CMMAVideoPlayer::HandleEvent:KMMFEventCategoryVideoRemoveSurface error, %d", aEvent.iErrorCode); |
|
313 } |
|
314 } |
|
315 // video opened, preparing |
|
316 else if (aEvent.iEventType == KMMFEventCategoryVideoOpenComplete) |
|
317 { |
|
318 if (aEvent.iErrorCode == KErrNone) |
|
319 { |
|
320 TInt error = iVideoPlaySurfaceSupportCustomCommands.UseSurfaces(); |
|
321 DEBUG_INT("MMA::CMMAVideoPlayer::HandleEvent::After UseSurfaces(), error = %d", error); |
|
322 TInt prepareError(iVideoPlayControllerCustomCommands.Prepare()); |
|
323 if (prepareError != KErrNone) |
|
324 { |
|
325 // opening failed, notifying java |
|
326 PostActionCompleted(prepareError); |
|
327 } |
|
328 } |
|
329 else |
|
330 { |
|
331 // opening failed, notifying java |
|
332 PostActionCompleted(aEvent.iErrorCode); |
|
333 } |
|
334 } |
|
335 // final state of prefetch ( prepare completed ) |
|
336 else if (aEvent.iEventType == KMMFEventCategoryVideoPrepareComplete) |
|
337 { |
|
338 // This callback must be handled differently depending on whether |
|
339 // player is created for a file locator or for a stream. When file |
|
340 // locator is used, this callback is made in realized state. For |
|
341 // stream it is made in prefetched state. |
|
342 PrepareDisplay(); |
|
343 if (iFileName) |
|
344 { |
|
345 DEBUG("CMMAVideoPlayer::HandleEvent: Using filename, change state to REALIZED"); |
|
346 |
|
347 // If there is an error condition, then the player state is not |
|
348 // changed, which indicates the error condition to StartL when |
|
349 // the ActiveSchedulerWait returns. KNotCompleteVideoError is not |
|
350 // considered as an error condition, instead it indicates that some |
|
351 // elements of the media cannot be played (e.g. video OR audio) |
|
352 if (aEvent.iErrorCode == KErrNone || |
|
353 aEvent.iErrorCode == KNotCompleteVideoError) |
|
354 { |
|
355 ChangeState(ERealized); |
|
356 } |
|
357 __ASSERT_DEBUG(iActiveSchedulerWait->IsStarted(), User::Invariant()); |
|
358 iActiveSchedulerWait->AsyncStop(); |
|
359 } |
|
360 else |
|
361 { |
|
362 DEBUG("CMMAVideoPlayer::HandleEvent: Not using filename, change state to PREFETCHED"); |
|
363 CompletePrefetch(aEvent.iErrorCode); |
|
364 } |
|
365 } |
|
366 else // in case of any other event |
|
367 { |
|
368 if (aEvent.iErrorCode != KErrNone) |
|
369 { |
|
370 PostActionCompleted(aEvent.iErrorCode); //some other error |
|
371 } |
|
372 } |
|
373 } |
|
374 |
|
375 void CMMAVideoPlayer::CompletePrefetch(TInt aError) |
|
376 { |
|
377 DEBUG_INT("CMMAVideoPlayer::CompletePrefetch + error = %d",aError); |
|
378 // Post KNotCompleteVideoError as KErrNone to the Java side, because |
|
379 // video can be played. |
|
380 if (aError == KNotCompleteVideoError) |
|
381 { |
|
382 DEBUG("CMMAVideoPlayer::CompletePrefetch KNotCompleteVideoError "); |
|
383 // release java |
|
384 PostActionCompleted(KErrNone); |
|
385 } |
|
386 else |
|
387 { |
|
388 DEBUG("CMMAVideoPlayer::CompletePrefetch CompleteVideoError "); |
|
389 // release java |
|
390 PostActionCompleted(aError); |
|
391 } |
|
392 |
|
393 if (aError == KErrNone || aError == KNotCompleteVideoError) |
|
394 { |
|
395 ChangeState(EPrefetched); |
|
396 } |
|
397 DEBUG("CMMAVideoPlayer::CompletePrefetch - "); |
|
398 } |
|
399 |
|
400 void CMMAVideoPlayer::PrepareDisplay() |
|
401 { |
|
402 DEBUG("CMMAVideoPlayer::PrepareDisplay +"); |
|
403 // construction should have leaved if iSurfaceWindow does not exist |
|
404 __ASSERT_DEBUG(iSurfaceWindow, |
|
405 User::Panic(_L("CMMVideoPlayer::iSurfaceWindow is null"), |
|
406 KErrArgument)); |
|
407 |
|
408 //First place where we are certain that source size can be fetched |
|
409 TSize sourceSize; |
|
410 |
|
411 TInt err = iVideoControllerCustomCommands.GetVideoFrameSize(sourceSize); |
|
412 |
|
413 DEBUG_INT("MID::CMMAVideoPlayer::PrepareDisplay: GetVideoFrameSize err = %d", err); |
|
414 |
|
415 // Still we did not get the size of video |
|
416 if ((err != KErrNone) || |
|
417 (sourceSize.iWidth <= 0) || |
|
418 (sourceSize.iHeight <= 0)) |
|
419 { |
|
420 DEBUG("MID::CMMAVideoPlayer::PrepareDisplay: No sourcesize found, using SurfaceWindow size"); |
|
421 // setting size to window size (client rect) |
|
422 sourceSize = iSurfaceWindow->WindowSize(); |
|
423 } |
|
424 |
|
425 // If 1x1 was got (the default size of form), it must be replaced |
|
426 // with a valid size as controller will not accept 1x1. |
|
427 if ((sourceSize.iWidth < KMMAVideoMinDimension) || |
|
428 (sourceSize.iHeight < KMMAVideoMinDimension)) |
|
429 { |
|
430 DEBUG("MID::CMMAVideoPlayer::PrepareDisplay: Unacceptable source size, using failsafe"); |
|
431 // This is a special case and ought to be used only in |
|
432 // the rare case that real size is not got from stream. |
|
433 sourceSize = TSize(KMMAVideoMinDimension, KMMAVideoMinDimension); |
|
434 } |
|
435 |
|
436 iSourceSize = sourceSize; |
|
437 |
|
438 // If init has been already done |
|
439 if (iDisplay) |
|
440 { |
|
441 DEBUG("MID::CMMAVideoPlayer::PrepareDisplay: display exists, changing source size"); |
|
442 SourceSizeChanged(); |
|
443 } |
|
444 |
|
445 // Setting (in)visible if something has changed the DSA state |
|
446 // (e.g. prepare). If initDisplayMode is not called, this will always |
|
447 // set visibility to false. |
|
448 iSurfaceWindow->SetVisible(iSurfaceWindow->IsVisible(), EFalse); |
|
449 DEBUG("CMMAVideoPlayer::PrepareDisplay -"); |
|
450 } |
|
451 |
|
452 EXPORT_C const TDesC& CMMAVideoPlayer::Type() |
|
453 { |
|
454 return KMMAVideoPlayer; |
|
455 } |
|
456 |
|
457 EXPORT_C TSize CMMAVideoPlayer::SourceSize() |
|
458 { |
|
459 return iSourceSize; |
|
460 } |
|
461 |
|
462 EXPORT_C MMMASnapshot::TEncoding CMMAVideoPlayer::TakeSnapshotL(TRequestStatus* aStatus, |
|
463 const TSize& /*aSize*/, |
|
464 const CMMAImageSettings& /*aSettings*/) |
|
465 { |
|
466 if (iEmptySnapshotImage) |
|
467 { |
|
468 // Ealier snapshot was not got with SnapshotBitmap method. |
|
469 User::Leave(KErrInUse); |
|
470 } |
|
471 // frame can't be got from video player, but TCK requires that it should |
|
472 // be available. So returning empty image |
|
473 iEmptySnapshotImage = new(ELeave) CFbsBitmap(); |
|
474 User::LeaveIfError(iEmptySnapshotImage->Create(TSize(1, 1), |
|
475 EColor4K)); |
|
476 |
|
477 |
|
478 User::RequestComplete(aStatus, KErrNone); |
|
479 |
|
480 // Return raw bitmap encoding and thus SnapshotEncoded() should not |
|
481 // get called later on. |
|
482 return EBitmap; |
|
483 } |
|
484 |
|
485 EXPORT_C CFbsBitmap* CMMAVideoPlayer::SnapshotBitmap() |
|
486 { |
|
487 // snapshot is not supported, returning empty image |
|
488 CFbsBitmap* image = iEmptySnapshotImage; |
|
489 |
|
490 // ownership is transferred to caller |
|
491 iEmptySnapshotImage = NULL; |
|
492 return image; |
|
493 } |
|
494 |
|
495 EXPORT_C HBufC8* CMMAVideoPlayer::SnapshotEncoded() |
|
496 { |
|
497 // This method should never be called. |
|
498 // Asserted in debug build to be sure. |
|
499 __ASSERT_DEBUG(EFalse, User::Invariant()); |
|
500 |
|
501 return NULL; |
|
502 } |
|
503 |
|
504 EXPORT_C void CMMAVideoPlayer::NotifyWithStringEvent( |
|
505 CMMAPlayerEvent::TEventType aEventType, |
|
506 const TDesC& aStringEventData) |
|
507 { |
|
508 PostStringEvent(aEventType, aStringEventData); |
|
509 } |
|
510 |
|
511 EXPORT_C MMMASnapshot* CMMAVideoPlayer::SnapshoterL() |
|
512 { |
|
513 return this; |
|
514 } |
|
515 |
|
516 void CMMAVideoPlayer::SourceSizeChanged() |
|
517 { |
|
518 iDisplay->SourceSizeChanged(iSourceSize); |
|
519 NotifyWithStringEvent(CMMAPlayerEvent::ESizeChanged, KVideoControlName); |
|
520 } |
|
521 |
|
522 // END OF FILE |