|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: This class is the interface between the playback plugin and RMMFController |
|
15 * |
|
16 */ |
|
17 |
|
18 // Version : %version: 12 % |
|
19 |
|
20 |
|
21 #include <AudioPreference.h> |
|
22 #include <mmf/server/mmffile.h> |
|
23 #include <caf/caftypes.h> |
|
24 #include <mpxmessagegeneraldefs.h> |
|
25 |
|
26 #include "mpxvideoplayerutility.h" |
|
27 #include "mpxvideoplaybackcontroller.h" |
|
28 #include <mpxvideoplaybackdefs.h> |
|
29 #include "mpxvideo_debug.h" |
|
30 |
|
31 const TInt KBufferExpandSize = 100; |
|
32 const TUid KSourceUid = { KMmfUidFileSource }; |
|
33 |
|
34 CMpxVideoPlayerUtility* |
|
35 CMpxVideoPlayerUtility::NewL( CMPXVideoPlaybackController* aVideoPlaybackCtrl ) |
|
36 { |
|
37 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::NewL()")); |
|
38 |
|
39 CMpxVideoPlayerUtility* self = new (ELeave) CMpxVideoPlayerUtility( aVideoPlaybackCtrl ); |
|
40 CleanupStack::PushL(self); |
|
41 self->ConstructL(); |
|
42 CleanupStack::Pop(); |
|
43 return self; |
|
44 } |
|
45 |
|
46 CMpxVideoPlayerUtility::CMpxVideoPlayerUtility( CMPXVideoPlaybackController* aVideoPlaybackCtrl ) |
|
47 : iVideoPlaybackController( aVideoPlaybackCtrl ) |
|
48 , iVideoControllerCustomCommands( iController ) |
|
49 , iVideoPlayControllerCustomCommands( iController ) |
|
50 , iAudioPlayDeviceCustomCommands( iController ) |
|
51 , iDrmCustomCommands( iController ) |
|
52 , iVideoPlayControllerExtCustomCommands( iController ) |
|
53 #ifdef SYMBIAN_BUILD_GCE |
|
54 , iVideoPlaySurfaceSupportCustomCommands( iController ) |
|
55 #endif |
|
56 { |
|
57 } |
|
58 |
|
59 void CMpxVideoPlayerUtility::ConstructL() |
|
60 { |
|
61 OpenControllerL(); |
|
62 } |
|
63 |
|
64 CMpxVideoPlayerUtility::~CMpxVideoPlayerUtility() |
|
65 { |
|
66 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::~CMpxVideoPlayerUtility()")); |
|
67 |
|
68 Close(); |
|
69 |
|
70 delete iControllerEventMonitor; |
|
71 } |
|
72 |
|
73 void CMpxVideoPlayerUtility::Close() |
|
74 { |
|
75 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::Close()")); |
|
76 |
|
77 if ( iControllerEventMonitor ) |
|
78 { |
|
79 iControllerEventMonitor->Cancel(); |
|
80 delete iControllerEventMonitor; |
|
81 iControllerEventMonitor = NULL; |
|
82 } |
|
83 |
|
84 iController.Close(); |
|
85 iDirectScreenAccessAbort = EFalse; |
|
86 } |
|
87 |
|
88 void CMpxVideoPlayerUtility::Reset() |
|
89 { |
|
90 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::Reset()")); |
|
91 |
|
92 Close(); |
|
93 OpenControllerL(); |
|
94 } |
|
95 |
|
96 void CMpxVideoPlayerUtility::OpenControllerL() |
|
97 { |
|
98 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::OpenControllerL()")); |
|
99 |
|
100 const TUid KHelixUID = {0x101F8514}; |
|
101 |
|
102 TMMFPrioritySettings settings; |
|
103 settings.iPriority = KAudioPriorityRealOnePlayer; |
|
104 settings.iPref = TMdaPriorityPreference( KAudioPrefRealOneLocalPlayback ); |
|
105 |
|
106 User::LeaveIfError( iController.Open( KHelixUID, settings, ETrue ) ); |
|
107 |
|
108 // |
|
109 // Let MMF Controller (Helix) handle evaluation & consumption of DRM rights |
|
110 // this call is necessary since default Helix behavior (for OMA 1&2) is to |
|
111 // not consume rights. Helix's default behavior for WMDRM is to consume rights. |
|
112 // This call ensures Helix will consume rights for all DRM types. |
|
113 // |
|
114 iDrmCustomCommands.DisableAutomaticIntent( EFalse ); |
|
115 |
|
116 // |
|
117 // Start monitoring controller events |
|
118 // |
|
119 if ( iControllerEventMonitor ) |
|
120 { |
|
121 iControllerEventMonitor->Cancel(); |
|
122 delete iControllerEventMonitor; |
|
123 iControllerEventMonitor = NULL; |
|
124 } |
|
125 |
|
126 iControllerEventMonitor = CMMFControllerEventMonitor::NewL( *this, iController ); |
|
127 |
|
128 iControllerEventMonitor->Start(); |
|
129 } |
|
130 |
|
131 TTimeIntervalMicroSeconds CMpxVideoPlayerUtility::PositionL() const |
|
132 { |
|
133 TTimeIntervalMicroSeconds position; |
|
134 User::LeaveIfError( iController.GetPosition( position ) ); |
|
135 |
|
136 MPX_DEBUG(_L("CMpxVideoPlayerUtility::PositionL(%Ld)"), position.Int64()); |
|
137 |
|
138 return position; |
|
139 } |
|
140 |
|
141 TTimeIntervalMicroSeconds CMpxVideoPlayerUtility::DurationL() const |
|
142 { |
|
143 TTimeIntervalMicroSeconds duration; |
|
144 User::LeaveIfError( iController.GetDuration( duration ) ); |
|
145 |
|
146 MPX_DEBUG(_L("CMpxVideoPlayerUtility::DurationL(%Ld)"), duration.Int64()); |
|
147 |
|
148 return duration; |
|
149 } |
|
150 |
|
151 TInt CMpxVideoPlayerUtility::NumberOfMetaDataEntriesL() const |
|
152 { |
|
153 TInt num = 0; |
|
154 User::LeaveIfError( iController.GetNumberOfMetaDataEntries( num ) ); |
|
155 |
|
156 MPX_DEBUG(_L("CMpxVideoPlayerUtility::NumberOfMetaDataEntriesL(%d)"), num); |
|
157 |
|
158 return num; |
|
159 } |
|
160 |
|
161 CMMFMetaDataEntry* CMpxVideoPlayerUtility::MetaDataEntryL( TInt aMetaDataIndex ) const |
|
162 { |
|
163 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::MetaDataEntryL()"), |
|
164 _L("index = %d"), aMetaDataIndex ); |
|
165 |
|
166 return iController.GetMetaDataEntryL( aMetaDataIndex ); |
|
167 } |
|
168 |
|
169 void CMpxVideoPlayerUtility::SetVolumeL( TInt aVolume ) |
|
170 { |
|
171 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::SetVolumeL()"), |
|
172 _L("volume = %d"), aVolume ); |
|
173 |
|
174 User::LeaveIfError( iAudioPlayDeviceCustomCommands.SetVolume( aVolume ) ); |
|
175 } |
|
176 |
|
177 TInt CMpxVideoPlayerUtility::Volume() const |
|
178 { |
|
179 TInt vol = 0; |
|
180 iAudioPlayDeviceCustomCommands.GetVolume( vol ); |
|
181 |
|
182 MPX_DEBUG(_L("CMpxVideoPlayerUtility::Volume(%d)"), vol); |
|
183 |
|
184 return vol; |
|
185 } |
|
186 |
|
187 TInt CMpxVideoPlayerUtility::MaxVolume() const |
|
188 { |
|
189 TInt maxVol = 0; |
|
190 iAudioPlayDeviceCustomCommands.GetMaxVolume( maxVol ); |
|
191 |
|
192 MPX_DEBUG(_L("CMpxVideoPlayerUtility::MaxVolume(%d)"), maxVol); |
|
193 |
|
194 return maxVol; |
|
195 } |
|
196 |
|
197 void CMpxVideoPlayerUtility::VideoFrameSizeL( TSize& aSize ) const |
|
198 { |
|
199 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::VideoFrameSizeL()")); |
|
200 User::LeaveIfError( iVideoControllerCustomCommands.GetVideoFrameSize( aSize ) ); |
|
201 } |
|
202 |
|
203 TInt CMpxVideoPlayerUtility::VideoBitRateL() const |
|
204 { |
|
205 TInt bitRate; |
|
206 User::LeaveIfError( iVideoControllerCustomCommands.GetVideoBitRate( bitRate ) ); |
|
207 |
|
208 MPX_DEBUG(_L("CMpxVideoPlayerUtility::VideoBitRateL(%d)"), bitRate); |
|
209 |
|
210 return bitRate; |
|
211 } |
|
212 TInt CMpxVideoPlayerUtility::AudioBitRateL() const |
|
213 { |
|
214 TInt bitRate; |
|
215 User::LeaveIfError( iVideoControllerCustomCommands.GetAudioBitRate( bitRate ) ); |
|
216 |
|
217 MPX_DEBUG(_L("CMpxVideoPlayerUtility::AudioBitRateL(%d)"), bitRate); |
|
218 |
|
219 return bitRate; |
|
220 } |
|
221 |
|
222 TInt CMpxVideoPlayerUtility::VideoFormatMimeType( TDes8& aMimeType ) const |
|
223 { |
|
224 return iVideoControllerCustomCommands.GetVideoMimeType( aMimeType ); |
|
225 } |
|
226 |
|
227 TUint32 CMpxVideoPlayerUtility::FourCCCode() const |
|
228 { |
|
229 TFourCC aFourCC( 0 ); |
|
230 iVideoControllerCustomCommands.GetAudioCodec( aFourCC ); |
|
231 |
|
232 return aFourCC.FourCC(); |
|
233 } |
|
234 |
|
235 void CMpxVideoPlayerUtility::RefreshFrameL() |
|
236 { |
|
237 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::RefreshFrameL()")); |
|
238 |
|
239 User::LeaveIfError( iVideoPlayControllerCustomCommands.RefreshFrame() ); |
|
240 } |
|
241 |
|
242 void CMpxVideoPlayerUtility::RestartDsa( const TRegion& aRegion ) |
|
243 { |
|
244 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::RestartDsa()")); |
|
245 |
|
246 iVideoPlayControllerCustomCommands.UpdateDisplayRegion( aRegion ); |
|
247 iVideoPlayControllerCustomCommands.DirectScreenAccessEvent( EResumeDSA ); |
|
248 } |
|
249 |
|
250 void CMpxVideoPlayerUtility::AbortDsa() |
|
251 { |
|
252 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::AbortDsa()")); |
|
253 |
|
254 iVideoPlayControllerCustomCommands.DirectScreenAccessEvent( EAbortDSA ); |
|
255 iDirectScreenAccessAbort = ETrue; |
|
256 } |
|
257 |
|
258 void CMpxVideoPlayerUtility::SetDisplayWindowL( const TRect& aScreenRect, |
|
259 const TRect& aClipRect, |
|
260 const TRegion& aDrawingRegion ) |
|
261 { |
|
262 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::SetDisplayWindowL()")); |
|
263 |
|
264 User::LeaveIfError( |
|
265 iVideoPlayControllerCustomCommands.SetDisplayWindow( aScreenRect, aClipRect) ); |
|
266 |
|
267 User::LeaveIfError( |
|
268 iVideoPlayControllerCustomCommands.UpdateDisplayRegion( aDrawingRegion ) ); |
|
269 |
|
270 if ( iDirectScreenAccessAbort ) |
|
271 { |
|
272 User::LeaveIfError( |
|
273 iVideoPlayControllerCustomCommands.DirectScreenAccessEvent( EResumeDSA ) ); |
|
274 |
|
275 iDirectScreenAccessAbort = EFalse; |
|
276 } |
|
277 } |
|
278 |
|
279 TBool CMpxVideoPlayerUtility::AudioEnabledL() const |
|
280 { |
|
281 TBool enabled; |
|
282 User::LeaveIfError( iVideoPlayControllerCustomCommands.GetAudioEnabled( enabled ) ); |
|
283 |
|
284 MPX_DEBUG(_L("CMpxVideoPlayerUtility::AudioEnabledL(%d)"), enabled); |
|
285 |
|
286 return enabled; |
|
287 } |
|
288 |
|
289 void CMpxVideoPlayerUtility::Prepare() |
|
290 { |
|
291 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::Prepare()")); |
|
292 |
|
293 TInt error = iVideoPlayControllerCustomCommands.Prepare(); |
|
294 |
|
295 if ( error ) |
|
296 { |
|
297 TMMFEvent event( KMMFEventCategoryVideoPrepareComplete, error ); |
|
298 iVideoPlaybackController->HandleMMFEvent( event ); |
|
299 } |
|
300 } |
|
301 |
|
302 void CMpxVideoPlayerUtility::GetVideoLoadingProgressL( TInt& aPercentageProgress ) |
|
303 { |
|
304 User::LeaveIfError( |
|
305 iVideoPlayControllerCustomCommands.GetLoadingProgress( aPercentageProgress ) ); |
|
306 |
|
307 MPX_DEBUG(_L("CMpxVideoPlayerUtility::GetVideoLoadingProgressL(%d)"), aPercentageProgress ); |
|
308 } |
|
309 |
|
310 void CMpxVideoPlayerUtility::Play() |
|
311 { |
|
312 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::Play()")); |
|
313 |
|
314 TInt err = iController.Play(); |
|
315 } |
|
316 |
|
317 void CMpxVideoPlayerUtility::PauseL() |
|
318 { |
|
319 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::PauseL()")); |
|
320 |
|
321 User::LeaveIfError( iController.Pause() ); |
|
322 } |
|
323 |
|
324 void CMpxVideoPlayerUtility::SetPlayVelocityL( TInt aVelocity ) |
|
325 { |
|
326 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::SetPlayVelocityL()"), |
|
327 _L("velocity = %d"), aVelocity); |
|
328 |
|
329 User::LeaveIfError( iVideoPlayControllerExtCustomCommands.SetPlayVelocity( aVelocity ) ); |
|
330 } |
|
331 |
|
332 void CMpxVideoPlayerUtility::SetPositionL(const TTimeIntervalMicroSeconds& aPosition) |
|
333 { |
|
334 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::SetPositionL()"), |
|
335 _L("aPosition = %Ld"), aPosition.Int64()); |
|
336 |
|
337 User::LeaveIfError( iController.SetPosition( aPosition ) ); |
|
338 } |
|
339 |
|
340 TInt CMpxVideoPlayerUtility::Stop() |
|
341 { |
|
342 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::Stop()")); |
|
343 |
|
344 return iController.Stop(); |
|
345 } |
|
346 |
|
347 void CMpxVideoPlayerUtility::HandleEvent( const TMMFEvent& aEvent ) |
|
348 { |
|
349 MPX_ENTER_EXIT( |
|
350 _L("CMpxVideoPlayerUtility::HandleEvent()"), |
|
351 _L("EventType = 0x%08x, ErrorCode = %d"), aEvent.iEventType, aEvent.iErrorCode ); |
|
352 |
|
353 // |
|
354 // Call on the controller to handle the event |
|
355 // |
|
356 iVideoPlaybackController->HandleMMFEvent( aEvent ); |
|
357 } |
|
358 |
|
359 void CMpxVideoPlayerUtility::OpenFileL( const RFile& aFile ) |
|
360 { |
|
361 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::OpenFileL()")); |
|
362 |
|
363 RFile& file = const_cast<RFile&>( aFile ); |
|
364 |
|
365 TMMFileHandleSource filehandlesource( file, |
|
366 ContentAccess::KDefaultContentObject, |
|
367 ContentAccess::EPlay ); |
|
368 |
|
369 HBufC* uniqueId = filehandlesource.UniqueId().AllocL(); |
|
370 CleanupStack::PushL( uniqueId ); |
|
371 |
|
372 TBool enableUi = filehandlesource.IsUIEnabled(); |
|
373 |
|
374 // |
|
375 // Create config for file handle source |
|
376 // |
|
377 CBufFlat* buf = CBufFlat::NewL( KBufferExpandSize ); |
|
378 CleanupStack::PushL( buf ); |
|
379 |
|
380 RBufWriteStream stream; |
|
381 stream.Open( *buf ); |
|
382 |
|
383 CleanupClosePushL( stream ); |
|
384 |
|
385 TPckgBuf<RFile*> fileptr( &file ); |
|
386 |
|
387 stream.WriteInt32L( KMMFileHandleSourceUid.iUid ); |
|
388 stream.WriteL( fileptr ); |
|
389 |
|
390 TInt length = 0; |
|
391 |
|
392 if ( uniqueId ) |
|
393 { |
|
394 length = uniqueId->Length(); |
|
395 } |
|
396 |
|
397 stream.WriteInt32L( length ); |
|
398 |
|
399 if ( length > 0 ) |
|
400 { |
|
401 stream.WriteL( *uniqueId ); |
|
402 } |
|
403 |
|
404 stream.WriteInt32L( enableUi ); |
|
405 |
|
406 stream.CommitL(); |
|
407 |
|
408 CleanupStack::PopAndDestroy( &stream ); |
|
409 |
|
410 HBufC8* sourceData = buf->Ptr(0).AllocL(); |
|
411 |
|
412 iController.AddDataSource( KSourceUid, sourceData->Des() ); |
|
413 iController.AddDataSink( KUidMmfAudioOutput, KNullDesC8 ); |
|
414 |
|
415 delete sourceData; |
|
416 |
|
417 #ifdef SYMBIAN_BUILD_GCE |
|
418 iVideoPlaySurfaceSupportCustomCommands.UseSurfaces(); |
|
419 #endif |
|
420 |
|
421 CleanupStack::PopAndDestroy( buf ); |
|
422 CleanupStack::PopAndDestroy( uniqueId ); |
|
423 } |
|
424 |
|
425 void CMpxVideoPlayerUtility::OpenFileL( const TDesC& aFileName ) |
|
426 { |
|
427 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::OpenFileL()"), |
|
428 _L("aFileName = %S"), &aFileName); |
|
429 |
|
430 TMMFFileConfig srcConfig; |
|
431 srcConfig().iPath = aFileName; |
|
432 |
|
433 const TUid KSourceUid = { KMmfUidFileSource }; |
|
434 |
|
435 iController.AddDataSource( KSourceUid, srcConfig ); |
|
436 iController.AddDataSink( KUidMmfAudioOutput, KNullDesC8 ); |
|
437 } |
|
438 |
|
439 void CMpxVideoPlayerUtility::OpenUrlL( const TDesC& aUrl, TInt aApId ) |
|
440 { |
|
441 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::OpenUrlL()"), |
|
442 _L("aUrl = %S, ApId = %d"), &aUrl, aApId); |
|
443 |
|
444 CBufFlat* urlCfgBuffer = NULL; |
|
445 |
|
446 CMMFUrlParams* urlCfg = CMMFUrlParams::NewL( aUrl, aApId ); |
|
447 CleanupStack::PushL( urlCfg ); |
|
448 |
|
449 urlCfgBuffer = urlCfg->ExternalizeToCBufFlatLC(); |
|
450 |
|
451 iController.AddDataSource( KUidMmfUrlSource, urlCfgBuffer->Ptr(0) ); |
|
452 iController.AddDataSink( KUidMmfAudioOutput, KNullDesC8 ); |
|
453 |
|
454 #ifdef SYMBIAN_BUILD_GCE |
|
455 iVideoPlaySurfaceSupportCustomCommands.UseSurfaces(); |
|
456 #endif |
|
457 |
|
458 CleanupStack::PopAndDestroy( 2 ); // urlCfg & urlCfgBuffer |
|
459 } |
|
460 |
|
461 TInt CMpxVideoPlayerUtility::CustomCommandSync( const TMMFMessageDestinationPckg& aDestination, |
|
462 TInt aFunction, |
|
463 const TDesC8& aDataTo1, |
|
464 const TDesC8& aDataTo2 ) |
|
465 { |
|
466 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::CustomCommandSync()")); |
|
467 |
|
468 return iController.CustomCommandSync( aDestination, aFunction, aDataTo1, aDataTo2 ); |
|
469 } |
|
470 |
|
471 |
|
472 #ifdef SYMBIAN_BUILD_GCE |
|
473 |
|
474 // ------------------------------------------------------------------------------------------------- |
|
475 // CMpxVideoPlayerUtility::VideoSurfaceCreated() |
|
476 // ------------------------------------------------------------------------------------------------- |
|
477 // |
|
478 TInt CMpxVideoPlayerUtility::VideoSurfaceCreated() |
|
479 { |
|
480 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::VideoSurfaceCreated()")); |
|
481 |
|
482 TSurfaceId oldSurfaceId( iSurfaceId ); |
|
483 TBool replaceSurface = ! ( iSurfaceId.IsNull() ); |
|
484 |
|
485 TSurfaceId surfaceId; |
|
486 TRect cropRect; |
|
487 TVideoAspectRatio aspectRatio; |
|
488 |
|
489 TInt error = |
|
490 iVideoPlaySurfaceSupportCustomCommands.GetSurfaceParameters( surfaceId, |
|
491 cropRect, |
|
492 aspectRatio ); |
|
493 |
|
494 if ( error == KErrNone ) |
|
495 { |
|
496 // |
|
497 // Send data to the display handler to remove old surface and add new surface |
|
498 // |
|
499 MPX_TRAPD( err, SendSurfaceCommandL( EPbMsgVideoSurfaceCreated, |
|
500 surfaceId, |
|
501 cropRect, |
|
502 aspectRatio ) ); |
|
503 |
|
504 iSurfaceId = surfaceId; |
|
505 |
|
506 // |
|
507 // if surface already existed tell video adaptation it is no longer in use. |
|
508 // Video adaptation will remove the surface when it receives this call therefore |
|
509 // the following code must be done at the end of this function. |
|
510 // |
|
511 if ( replaceSurface ) |
|
512 { |
|
513 error = iVideoPlaySurfaceSupportCustomCommands.SurfaceRemoved( oldSurfaceId ); |
|
514 } |
|
515 } |
|
516 else |
|
517 { |
|
518 if ( replaceSurface ) |
|
519 { |
|
520 iVideoPlaySurfaceSupportCustomCommands.SurfaceRemoved( oldSurfaceId ); |
|
521 } |
|
522 } |
|
523 |
|
524 return error; |
|
525 } |
|
526 |
|
527 // ------------------------------------------------------------------------------------------------- |
|
528 // CMpxVideoPlayerUtility::SurfaceParametersChanged() |
|
529 // ------------------------------------------------------------------------------------------------- |
|
530 // |
|
531 TInt CMpxVideoPlayerUtility::SurfaceParametersChanged() |
|
532 { |
|
533 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::SurfaceParametersChanged()")); |
|
534 |
|
535 TInt error = KErrNone; |
|
536 |
|
537 if ( iSurfaceId.IsNull() ) |
|
538 { |
|
539 error = KErrNotSupported; |
|
540 } |
|
541 else |
|
542 { |
|
543 TSurfaceId surfaceId; |
|
544 TRect cropRect; |
|
545 TVideoAspectRatio aspectRatio; |
|
546 |
|
547 error = iVideoPlaySurfaceSupportCustomCommands.GetSurfaceParameters( surfaceId, |
|
548 cropRect, |
|
549 aspectRatio ); |
|
550 |
|
551 if ( error == KErrNone ) |
|
552 { |
|
553 if ( iSurfaceId != surfaceId ) |
|
554 { |
|
555 error = KErrInUse; |
|
556 } |
|
557 else |
|
558 { |
|
559 // |
|
560 // Send data to the display handler to remove old surface and add new surface |
|
561 // |
|
562 MPX_TRAPD( err, SendSurfaceCommandL( EPbMsgVideoSurfaceChanged, |
|
563 surfaceId, |
|
564 cropRect, |
|
565 aspectRatio ) ); |
|
566 } |
|
567 } |
|
568 } |
|
569 |
|
570 return error; |
|
571 } |
|
572 |
|
573 // ------------------------------------------------------------------------------------------------- |
|
574 // CMpxVideoPlayerUtility::RemoveSurface() |
|
575 // ------------------------------------------------------------------------------------------------- |
|
576 // |
|
577 TInt CMpxVideoPlayerUtility::RemoveSurface() |
|
578 { |
|
579 TInt error = KErrNone; |
|
580 |
|
581 if ( iSurfaceId.IsNull() ) |
|
582 { |
|
583 error = KErrNotFound; |
|
584 } |
|
585 |
|
586 // |
|
587 // Send command to view to remove the surface |
|
588 // |
|
589 MPX_TRAPD( err, SendSurfaceCommandL( EPbMsgVideoSurfaceRemoved ) ); |
|
590 |
|
591 error = iVideoPlaySurfaceSupportCustomCommands.SurfaceRemoved( iSurfaceId ); |
|
592 |
|
593 iSurfaceId = TSurfaceId::CreateNullId(); |
|
594 |
|
595 return error; |
|
596 } |
|
597 |
|
598 // ------------------------------------------------------------------------------------------------- |
|
599 // CMpxVideoPlayerUtility::SendSurfaceCommandL() |
|
600 // ------------------------------------------------------------------------------------------------- |
|
601 // |
|
602 void CMpxVideoPlayerUtility::SendSurfaceCommandL( TInt aCmd ) |
|
603 { |
|
604 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::SendSurfaceCommandL()"), |
|
605 _L("aCmd = %d"), aCmd ); |
|
606 |
|
607 if ( iVideoPlaybackController->iMPXPluginObs ) |
|
608 { |
|
609 CMPXMessage* msg = CMPXMessage::NewL(); |
|
610 CleanupStack::PushL( msg ); |
|
611 |
|
612 msg->SetTObjectValueL<TInt>( KMPXMessageGeneralId, KMPXMediaIdVideoDisplayMessage ); |
|
613 msg->SetTObjectValueL<TInt>( KMPXMediaVideoDisplayCommand, aCmd ); |
|
614 |
|
615 iVideoPlaybackController->iMPXPluginObs->HandlePlaybackMessage( msg, KErrNone ); |
|
616 |
|
617 CleanupStack::PopAndDestroy( msg ); |
|
618 } |
|
619 } |
|
620 |
|
621 // ------------------------------------------------------------------------------------------------- |
|
622 // CMpxVideoPlayerUtility::SendSurfaceCommandL() |
|
623 // ------------------------------------------------------------------------------------------------- |
|
624 // |
|
625 void CMpxVideoPlayerUtility::SendSurfaceCommandL( TInt aCmd, |
|
626 const TSurfaceId& aSurfaceId, |
|
627 const TRect& aCropRect, |
|
628 TVideoAspectRatio aAspectRatio ) |
|
629 { |
|
630 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::SendSurfaceCommandL()"), |
|
631 _L("aCmd = %d"), aCmd ); |
|
632 |
|
633 if ( iVideoPlaybackController->iMPXPluginObs ) |
|
634 { |
|
635 CMPXMessage* msg = CMPXMessage::NewL(); |
|
636 CleanupStack::PushL( msg ); |
|
637 |
|
638 msg->SetTObjectValueL<TInt>( KMPXMessageGeneralId, KMPXMediaIdVideoDisplayMessage ); |
|
639 msg->SetTObjectValueL<TInt>( KMPXMediaVideoDisplayCommand, aCmd ); |
|
640 msg->SetTObjectValueL<TSurfaceId>( KMPXMediaVideoDisplayTSurfaceId, aSurfaceId ); |
|
641 msg->SetTObjectValueL<TRect>( KMPXMediaVideoDisplayCropRect, aCropRect ); |
|
642 msg->SetTObjectValueL<TVideoAspectRatio>( KMPXMediaVideoDisplayAspectRatio, aAspectRatio ); |
|
643 |
|
644 iVideoPlaybackController->iMPXPluginObs->HandlePlaybackMessage( msg, KErrNone ); |
|
645 |
|
646 CleanupStack::PopAndDestroy( msg ); |
|
647 } |
|
648 } |
|
649 |
|
650 #endif |
|
651 |
|
652 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API |
|
653 |
|
654 void CMpxVideoPlayerUtility::OpenFile64L( const RFile64& aFile ) |
|
655 { |
|
656 MPX_ENTER_EXIT(_L("CMpxVideoPlayerUtility::OpenFile64L( RFile64 )")); |
|
657 |
|
658 RFile64& file = const_cast<RFile64&>( aFile ); |
|
659 |
|
660 TMMFileHandleSource filehandlesource( file, |
|
661 ContentAccess::KDefaultContentObject, |
|
662 ContentAccess::EPlay ); |
|
663 |
|
664 HBufC* uniqueId = filehandlesource.UniqueId().AllocL(); |
|
665 CleanupStack::PushL( uniqueId ); |
|
666 |
|
667 TBool enableUi = filehandlesource.IsUIEnabled(); |
|
668 |
|
669 // |
|
670 // Create config for file handle source |
|
671 // |
|
672 CBufFlat* buf = CBufFlat::NewL( KBufferExpandSize ); |
|
673 CleanupStack::PushL( buf ); |
|
674 |
|
675 RBufWriteStream stream; |
|
676 stream.Open( *buf ); |
|
677 |
|
678 CleanupClosePushL( stream ); |
|
679 |
|
680 TPckgBuf<RFile64*> fileptr( &file ); |
|
681 |
|
682 stream.WriteInt32L( KMMFileHandleSourceUid.iUid ); |
|
683 stream.WriteL( fileptr ); |
|
684 |
|
685 TInt length = 0; |
|
686 |
|
687 if ( uniqueId ) |
|
688 { |
|
689 length = uniqueId->Length(); |
|
690 } |
|
691 |
|
692 stream.WriteInt32L( length ); |
|
693 |
|
694 if ( length > 0 ) |
|
695 { |
|
696 stream.WriteL( *uniqueId ); |
|
697 } |
|
698 |
|
699 stream.WriteInt32L( enableUi ); |
|
700 |
|
701 stream.CommitL(); |
|
702 |
|
703 CleanupStack::PopAndDestroy( &stream ); |
|
704 |
|
705 HBufC8* sourceData = buf->Ptr(0).AllocL(); |
|
706 |
|
707 iController.AddDataSource( KSourceUid, sourceData->Des() ); |
|
708 iController.AddDataSink( KUidMmfAudioOutput, KNullDesC8 ); |
|
709 |
|
710 delete sourceData; |
|
711 |
|
712 #ifdef SYMBIAN_BUILD_GCE |
|
713 iVideoPlaySurfaceSupportCustomCommands.UseSurfaces(); |
|
714 #endif |
|
715 |
|
716 CleanupStack::PopAndDestroy( buf ); |
|
717 CleanupStack::PopAndDestroy( uniqueId ); |
|
718 } |
|
719 |
|
720 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API |
|
721 |