76 |
76 |
77 Interface UID and messages for the Audio Resource Notification API. |
77 Interface UID and messages for the Audio Resource Notification API. |
78 */ |
78 */ |
79 const TUid KMMFEventCategoryAudioResourceAvailable = {0x101FD9F2}; |
79 const TUid KMMFEventCategoryAudioResourceAvailable = {0x101FD9F2}; |
80 |
80 |
81 /** |
|
82 @internalComponent |
|
83 */ |
|
84 enum TMMFAudioResourceNotificationMessages |
|
85 { |
|
86 EMMFAudioResourceRegisterNotification, |
|
87 EMMFAudioResourceCancelRegisterNotification, |
|
88 EMMFAudioResourceGetNotificationData, |
|
89 EMMFAudioResourceWillResumePlay |
|
90 }; |
|
91 |
81 |
92 /** |
82 /** |
93 @publishedAll |
83 @publishedAll |
94 @released |
84 @released |
95 |
85 |
96 Interface UID and messages for the Audio Play Device API. |
86 Interface UID and messages for the Audio Play Device API. |
97 */ |
87 */ |
98 const TUid KUidInterfaceMMFAudioPlayDevice = {0x101F76D6}; |
88 const TUid KUidInterfaceMMFAudioPlayDevice = {0x101F76D6}; |
99 |
89 |
100 /** |
90 /** |
101 @internalComponent |
|
102 */ |
|
103 enum TMMFAudioPlayDeviceMessages |
|
104 { |
|
105 EMMFAudioPlayDeviceSetVolume, |
|
106 EMMFAudioPlayDeviceGetMaxVolume, |
|
107 EMMFAudioPlayDeviceGetVolume, |
|
108 EMMFAudioPlayDeviceSetVolumeRamp, |
|
109 EMMFAudioPlayDeviceSetBalance, |
|
110 EMMFAudioPlayDeviceGetBalance |
|
111 }; |
|
112 |
|
113 /** |
|
114 @publishedAll |
91 @publishedAll |
115 @released |
92 @released |
116 |
93 |
117 Interface UID and messages for the Audio Record Device API. |
94 Interface UID and messages for the Audio Record Device API. |
118 */ |
95 */ |
119 const TUid KUidInterfaceMMFAudioRecordDevice = {0x101F76D7}; |
96 const TUid KUidInterfaceMMFAudioRecordDevice = {0x101F76D7}; |
120 |
97 |
121 /** |
98 /** |
122 @internalComponent |
|
123 */ |
|
124 enum TMMFAudioRecordDeviceMessage |
|
125 { |
|
126 EMMFAudioRecordDeviceSetGain, |
|
127 EMMFAudioRecordDeviceGetMaxGain, |
|
128 EMMFAudioRecordDeviceGetGain, |
|
129 EMMFAudioRecordDeviceSetBalance, |
|
130 EMMFAudioRecordDeviceGetBalance |
|
131 }; |
|
132 |
|
133 /** |
|
134 @publishedAll |
99 @publishedAll |
135 @released |
100 @released |
136 |
101 |
137 Interface UID and messages for the Audio Play Controller API. |
102 Interface UID and messages for the Audio Play Controller API. |
138 */ |
103 */ |
139 const TUid KUidInterfaceMMFAudioPlayController = {0x101F76D8}; |
104 const TUid KUidInterfaceMMFAudioPlayController = {0x101F76D8}; |
140 |
105 |
141 /** |
106 /** |
142 @internalComponent |
|
143 */ |
|
144 enum TMMFAudioPlayControllerMessages |
|
145 { |
|
146 EMMFAudioPlayControllerSetPlaybackWindow, |
|
147 EMMFAudioPlayControllerDeletePlaybackWindow, |
|
148 EMMFAudioPlayControllerGetLoadingProgress |
|
149 }; |
|
150 |
|
151 /** |
|
152 @publishedAll |
107 @publishedAll |
153 @released |
108 @released |
154 |
109 |
155 Interface UID and messages for the Audio Record Controller API. |
110 Interface UID and messages for the Audio Record Controller API. |
156 */ |
111 */ |
157 const TUid KUidInterfaceMMFAudioRecordController = {0x101F76D9}; |
112 const TUid KUidInterfaceMMFAudioRecordController = {0x101F76D9}; |
158 |
113 |
159 /** |
114 /** |
160 @internalComponent |
|
161 */ |
|
162 enum TMMFAudioRecordControllerMessages |
|
163 { |
|
164 EMMFAudioRecordControllerGetRecordTimeAvailable, |
|
165 EMMFAudioRecordControllerSetMaxDuration, |
|
166 EMMFAudioRecordControllerSetMaxFileSize, |
|
167 EMMFAudioRecordControllerCrop, |
|
168 EMMFAudioRecordControllerAddMetaDataEntry, |
|
169 EMMFAudioRecordControllerRemoveMetaDataEntry, |
|
170 EMMFAudioRecordControllerReplaceMetaDataEntry |
|
171 }; |
|
172 |
|
173 /** |
|
174 @publishedAll |
115 @publishedAll |
175 @released |
116 @released |
176 |
117 |
177 Interface UID and messages for the Audio Controller API. |
118 Interface UID and messages for the Audio Controller API. |
178 */ |
119 */ |
179 const TUid KUidInterfaceMMFAudioController = {0x101F76DA}; |
120 const TUid KUidInterfaceMMFAudioController = {0x101F76DA}; |
180 |
121 |
181 /** |
122 /** |
182 @internalComponent |
|
183 */ |
|
184 enum TMMFAudioControllerMessages |
|
185 { |
|
186 EMMFAudioControllerSetSourceSampleRate, |
|
187 EMMFAudioControllerSetSourceNumChannels, |
|
188 EMMFAudioControllerSetSourceFormat, |
|
189 EMMFAudioControllerSetSourceBitRate, |
|
190 EMMFAudioControllerSetSourceDataType, |
|
191 EMMFAudioControllerSetSinkSampleRate, |
|
192 EMMFAudioControllerSetSinkNumChannels, |
|
193 EMMFAudioControllerSetSinkFormat, |
|
194 EMMFAudioControllerSetSinkBitRate, |
|
195 EMMFAudioControllerSetSinkDataType, |
|
196 EMMFAudioControllerGetSourceSampleRate, |
|
197 EMMFAudioControllerGetSourceBitRate, |
|
198 EMMFAudioControllerGetSourceNumChannels, |
|
199 EMMFAudioControllerGetSourceFormat, |
|
200 EMMFAudioControllerGetSourceDataType, |
|
201 EMMFAudioControllerGetSinkSampleRate, |
|
202 EMMFAudioControllerGetSinkBitRate, |
|
203 EMMFAudioControllerGetSinkNumChannels, |
|
204 EMMFAudioControllerGetSinkFormat, |
|
205 EMMFAudioControllerGetSinkDataType, |
|
206 EMMFAudioControllerGetSupportedSourceSampleRates, |
|
207 EMMFAudioControllerGetSupportedSourceBitRates, |
|
208 EMMFAudioControllerGetSupportedSourceNumChannels, |
|
209 EMMFAudioControllerGetSupportedSourceDataTypes, |
|
210 EMMFAudioControllerGetSupportedSinkSampleRates, |
|
211 EMMFAudioControllerGetSupportedSinkBitRates, |
|
212 EMMFAudioControllerGetSupportedSinkNumChannels, |
|
213 EMMFAudioControllerGetSupportedSinkDataTypes, |
|
214 EMMFAudioControllerCopyArrayData, |
|
215 EMMFAudioControllerSetCodec |
|
216 }; |
|
217 |
|
218 |
|
219 /** |
|
220 @publishedAll |
123 @publishedAll |
221 @released |
124 @released |
222 */ |
125 */ |
223 const TUid KUidInterfaceMMFVideoController = {0x101F76DB}; |
126 const TUid KUidInterfaceMMFVideoController = {0x101F76DB}; |
224 |
127 |
225 /** |
128 /** |
226 @internalComponent |
|
227 */ |
|
228 enum TMMFVideoControllerMessages |
|
229 { |
|
230 EMMFVideoControllerGetAudioCodec, |
|
231 EMMFVideoControllerGetVideoBitRate, |
|
232 EMMFVideoControllerGetAudioBitRate, |
|
233 EMMFVideoControllerGetVideoFrameSize, |
|
234 EMMFVideoControllerSetFrameRate, |
|
235 EMMFVideoControllerGetFrameRate, |
|
236 EMMFVideoControllerGetVideoMimeType |
|
237 }; |
|
238 |
|
239 /** |
|
240 @publishedAll |
129 @publishedAll |
241 @released |
130 @released |
242 */ |
131 */ |
243 const TUid KUidInterfaceMMFVideoPlayController = {0x101F7B73}; |
132 const TUid KUidInterfaceMMFVideoPlayController = {0x101F7B73}; |
244 |
133 |
245 /** |
134 /** |
246 @internalComponent |
|
247 */ |
|
248 enum TMMFVideoPlayControllerMessages |
|
249 { |
|
250 EMMFVideoPlayControllerPrepare, |
|
251 EMMFVideoPlayControllerGetFrame, |
|
252 EMMFVideoPlayControllerSetDisplayWindow, |
|
253 EMMFVideoPlayControllerGetAudioEnabled, |
|
254 EMMFVideoPlayControllerUpdateDisplayRegion, |
|
255 EMMFVideoPlayControllerDSAEvent, |
|
256 EMMFVideoPlayControllerPlay, |
|
257 EMMFVideoPlayControllerRefreshFrame, |
|
258 EMMFVideoPlayControllerGetLoadingProgress, |
|
259 EMMFVideoPlayControllerSetRotation, |
|
260 EMMFVideoPlayControllerGetRotation, |
|
261 EMMFVideoPlayControllerSetScaleFactor, |
|
262 EMMFVideoPlayControllerGetScaleFactor, |
|
263 EMMFVideoPlayControllerSetCropRegion, |
|
264 EMMFVideoPlayControllerGetCropRegion |
|
265 }; |
|
266 |
|
267 /** |
|
268 @publishedAll |
135 @publishedAll |
269 @released |
136 @released |
270 */ |
137 */ |
271 const TUid KUidInterfaceMMFVideoRecordController = {0x101F7B74}; |
138 const TUid KUidInterfaceMMFVideoRecordController = {0x101F7B74}; |
272 |
139 |
273 /** |
140 /** |
274 @internalComponent |
|
275 */ |
|
276 enum TMMFVideoRecordControllerMessages |
|
277 { |
|
278 EMMFVideoRecordControllerSetVideoFormat, |
|
279 EMMFVideoRecordControllerSetVideoCodec, |
|
280 EMMFVideoRecordControllerSetAudioCodec, |
|
281 EMMFVideoRecordControllerSetVideoBitRate, |
|
282 EMMFVideoRecordControllerSetAudioBitRate, |
|
283 EMMFVideoRecordControllerSetVideoFrameSize, |
|
284 EMMFVideoRecordControllerSetMaxFileSize, |
|
285 EMMFVideoRecordControllerAddMetaDataEntry, |
|
286 EMMFVideoRecordControllerRemoveMetaDataEntry, |
|
287 EMMFVideoRecordControllerReplaceMetaDataEntry, |
|
288 EMMFVideoRecordControllerSetAudioEnabled, |
|
289 EMMFVideoRecordControllerPrepare, |
|
290 EMMFVideoRecordControllerSetCameraHandle, |
|
291 EMMFVideoRecordControllerGetRecordTimeAvailable, |
|
292 EMMFVideoRecordControllerGetSupportedSinkAudioTypes, |
|
293 EMMFVideoRecordControllerGetSupportedSinkVideoTypes, |
|
294 EMMFVideoRecordControllerCopyDescriptorArrayData, |
|
295 EMMFVideoRecordControllerCopyFourCCArrayData, |
|
296 EMMFVideoRecordControllerGetAudioEnabled // INC23777 |
|
297 }; |
|
298 |
|
299 /** |
|
300 @publishedAll |
141 @publishedAll |
301 @released |
142 @released |
302 */ |
143 */ |
303 const TUid KUidInterfaceMMFVideoDRMExt = {0x101F7C23}; |
144 const TUid KUidInterfaceMMFVideoDRMExt = {0x101F7C23}; |
304 |
145 |
305 /** |
146 /** |
306 @internalComponent |
|
307 */ |
|
308 enum TMMFDRMIntentMessages |
|
309 { |
|
310 EMMFVideoDRMExtGetFrame |
|
311 }; |
|
312 |
|
313 /** |
|
314 @publishedAll |
147 @publishedAll |
315 @released |
148 @released |
316 |
149 |
317 Interface UID for the custom command that supports setting the initial screen for video on the controller. |
150 Interface UID for the custom command that supports setting the initial screen for video on the controller. |
318 */ |
151 */ |
319 const TUid KUidInterfaceMMFVideoSetInitScreen = {0x102825F7}; |
152 const TUid KUidInterfaceMMFVideoSetInitScreen = {0x102825F7}; |
320 |
153 |
321 /** |
154 /** |
322 @internalComponent |
155 @publishedAll |
323 */ |
156 @released |
324 enum TMMFVideoScreenDeviceMessages |
|
325 { |
|
326 EMMFVideoSetInitScreenNumber |
|
327 }; |
|
328 |
|
329 |
|
330 /** |
|
331 @publishedAll |
|
332 @prototype |
|
333 */ |
157 */ |
334 const TUid KUidInterfaceMMFVideoPixelAspectRatio = {0x102831EF}; |
158 const TUid KUidInterfaceMMFVideoPixelAspectRatio = {0x102831EF}; |
335 |
159 |
336 /** |
160 |
337 @internalComponent |
161 /** |
338 */ |
162 @publishedAll |
339 enum TMMFVideoPixelAspectRatioMessages |
163 @released |
340 { |
|
341 EMMFVideoGetPixelAspectRatio, |
|
342 EMMFVideoSetPixelAspectRatio, |
|
343 EMMFVideoGetSupportedPixelAspectRatios, |
|
344 EMMFVideoPixelAspectRatioCopyArrayData |
|
345 }; |
|
346 |
|
347 /** |
|
348 @publishedAll |
|
349 @prototype |
|
350 */ |
164 */ |
351 const TUid KUidInterfaceMMFVideoAudioSamplingRateAndChannelConfig = {0x102831F0}; |
165 const TUid KUidInterfaceMMFVideoAudioSamplingRateAndChannelConfig = {0x102831F0}; |
352 |
|
353 /** |
|
354 @internalComponent |
|
355 */ |
|
356 enum TMMFVideoAudioSamplingRateAndChannelConfigMessages |
|
357 { |
|
358 EMMFVideoGetAudioChannels, |
|
359 EMMFVideoSetAudioChannels, |
|
360 EMMFVideoGetSupportedAudioChannels, |
|
361 EMMFVideoGetAudioSampleRate, |
|
362 EMMFVideoSetAudioSampleRate, |
|
363 EMMFVideoGetSupportedAudioSampleRates, |
|
364 EMMFVideoAudioSamplingRateAndChannelConfigCopyArrayData |
|
365 }; |
|
366 |
166 |
367 /** |
167 /** |
368 @publishedAll |
168 @publishedAll |
369 @released |
169 @released |
370 |
170 |
3892 TBool DoWillResumePlayL(TMMFMessage& aMessage); |
3765 TBool DoWillResumePlayL(TMMFMessage& aMessage); |
3893 private: |
3766 private: |
3894 MMMFResourceNotificationCustomCommandImplementor& iImplementor; |
3767 MMMFResourceNotificationCustomCommandImplementor& iImplementor; |
3895 }; |
3768 }; |
3896 |
3769 |
3897 /** |
3770 |
3898 @publishedPartner |
|
3899 @prototype |
|
3900 |
|
3901 Client class to allow setting the initial screen for video display. |
|
3902 |
|
3903 */ |
|
3904 class RMMFVideoSetInitScreenCustomCommands : public RMMFCustomCommandsBase |
|
3905 { |
|
3906 public: |
|
3907 |
|
3908 /** |
|
3909 Constructor. |
|
3910 |
|
3911 @param aController |
|
3912 The client side controller object to be used by this custom command interface. |
|
3913 |
|
3914 */ |
|
3915 IMPORT_C RMMFVideoSetInitScreenCustomCommands(RMMFController& aController); |
|
3916 |
|
3917 /** |
|
3918 Sets the initial screen number for the video display on the controller. |
|
3919 |
|
3920 @param aScreenNumber |
|
3921 The screen number |
|
3922 |
|
3923 */ |
|
3924 IMPORT_C TInt SetInitScreenNumber(TInt aScreenNumber); |
|
3925 }; |
|
3926 |
|
3927 |
|
3928 |
|
3929 /** |
|
3930 @publishedPartner |
|
3931 @prototype |
|
3932 |
|
3933 Mixin class to be derived from controller plugins that could support setting the initial screen for displaying video. |
|
3934 */ |
|
3935 class MMMFVideoSetInitScreenCustomCommandImplementor |
|
3936 { |
|
3937 public: |
|
3938 |
|
3939 /** |
|
3940 Sets the initial screen number. |
|
3941 |
|
3942 @param aScreenNumber |
|
3943 The screen number |
|
3944 */ |
|
3945 virtual void MvsdSetInitScreenNumber(TInt aScreenNumber)=0; |
|
3946 }; |
|
3947 |
|
3948 |
|
3949 /** |
|
3950 @publishedPartner |
|
3951 @prototype |
|
3952 |
|
3953 Custom command parser class to be used by controller plugins wishing to support setting the initial screen |
|
3954 number for the video display. |
|
3955 |
|
3956 The controller plugin should create an object of this type and add it to the list of custom command parsers |
|
3957 in the controller framework. The controller plugin must be derived from MMMFVideoSetInitScreenCustomCommandImplementor |
|
3958 to use this class. |
|
3959 */ |
|
3960 class CMMFVideoSetInitScreenCustomCommandParser : public CMMFCustomCommandParserBase |
|
3961 { |
|
3962 public: |
|
3963 |
|
3964 /** |
|
3965 Creates a new custom command parser that supports setting screen device for video dusplay. |
|
3966 |
|
3967 @param aImplementor |
|
3968 A reference to the controller plugin that owns this new object. |
|
3969 |
|
3970 @return A pointer to the object created. |
|
3971 |
|
3972 */ |
|
3973 IMPORT_C static CMMFVideoSetInitScreenCustomCommandParser* NewL(MMMFVideoSetInitScreenCustomCommandImplementor& aImplementor); |
|
3974 |
|
3975 /** |
|
3976 Destructor. |
|
3977 |
|
3978 */ |
|
3979 IMPORT_C ~CMMFVideoSetInitScreenCustomCommandParser(); |
|
3980 |
|
3981 /** |
|
3982 Handles a request from the client. Called by the controller framework. |
|
3983 |
|
3984 @param aMessage |
|
3985 The message to be handled. |
|
3986 |
|
3987 */ |
|
3988 void HandleRequest(TMMFMessage& aMessage); |
|
3989 |
|
3990 private: |
|
3991 /** |
|
3992 Constructor. |
|
3993 |
|
3994 @param aImplementor |
|
3995 A reference to the controller plugin that owns this new object. |
|
3996 */ |
|
3997 CMMFVideoSetInitScreenCustomCommandParser(MMMFVideoSetInitScreenCustomCommandImplementor& aImplementor); |
|
3998 void DoHandleRequestL(TMMFMessage& aMessage); |
|
3999 TBool DoSetInitScreenNumberL(TMMFMessage& aMessage); |
|
4000 |
|
4001 private: |
|
4002 MMMFVideoSetInitScreenCustomCommandImplementor& iImplementor; |
|
4003 }; |
|
4004 |
|
4005 |
|
4006 /** |
|
4007 @publishedPartner |
|
4008 @prototype |
|
4009 |
|
4010 Client class to allow setting and getting the pixel aspect ratio for video recording. |
|
4011 |
|
4012 */ |
|
4013 class RMMFVideoPixelAspectRatioCustomCommands : public RMMFCustomCommandsBase |
|
4014 { |
|
4015 public: |
|
4016 |
|
4017 /** |
|
4018 Constructor. |
|
4019 |
|
4020 @param aController |
|
4021 The client side controller object to be used by this custom command interface. |
|
4022 |
|
4023 */ |
|
4024 IMPORT_C RMMFVideoPixelAspectRatioCustomCommands(RMMFController& aController); |
|
4025 |
|
4026 /** |
|
4027 Sets the pixel aspect ratio for the video recording on the controller. |
|
4028 |
|
4029 @param aAspectRatio |
|
4030 The new pixel aspect ratio. The default pixel aspect ratio is 1:1. |
|
4031 |
|
4032 @return One of the system-wide error codes. |
|
4033 |
|
4034 */ |
|
4035 IMPORT_C TInt SetPixelAspectRatio(const TVideoAspectRatio& aAspectRatio); |
|
4036 |
|
4037 /** |
|
4038 Gets the current pixel aspect ratio for the video recording on the controller. |
|
4039 |
|
4040 @param aAspectRatio |
|
4041 The current video pixel aspect ratio. |
|
4042 |
|
4043 @return One of the system-wide error codes. |
|
4044 */ |
|
4045 IMPORT_C TInt GetPixelAspectRatio(TVideoAspectRatio& aAspectRatio) const; |
|
4046 |
|
4047 /** |
|
4048 Gets the list of supported pixel aspect ratios for the video recording on the controller. |
|
4049 |
|
4050 @param aAspectRatios |
|
4051 The supported pixel aspect ratios. |
|
4052 |
|
4053 @leave This method may leave with one of the system-wide error codes. |
|
4054 */ |
|
4055 IMPORT_C void GetSupportedPixelAspectRatiosL(RArray<TVideoAspectRatio>& aAspectRatios) const; |
|
4056 |
|
4057 private: |
|
4058 void DoGetVideoPixelAspectRatioArrayL(RArray<TVideoAspectRatio>& aArray, TMMFVideoPixelAspectRatioMessages aIpc) const; |
|
4059 }; |
|
4060 |
|
4061 |
|
4062 /** |
|
4063 @publishedPartner |
|
4064 @prototype |
|
4065 |
|
4066 Mixin class to be derived from controller plug-ins that could support setting and getting the pixel aspect ratio for video recording. |
|
4067 */ |
|
4068 class MMMFVideoPixelAspectRatioCustomCommandImplementor |
|
4069 { |
|
4070 public: |
|
4071 |
|
4072 /** |
|
4073 Sets the pixel aspect ratio. |
|
4074 |
|
4075 @param aAspectRatio |
|
4076 The pixel aspect ratio to use. |
|
4077 */ |
|
4078 virtual void MvparSetPixelAspectRatioL(const TVideoAspectRatio& aAspectRatio) = 0; |
|
4079 |
|
4080 /** |
|
4081 Gets the current pixel aspect ratio. |
|
4082 |
|
4083 @param aAspectRatio |
|
4084 The current pixel aspect ratio. |
|
4085 */ |
|
4086 virtual void MvparGetPixelAspectRatioL(TVideoAspectRatio& aAspectRatio) = 0; |
|
4087 |
|
4088 /** |
|
4089 Gets the list of supported pixel aspect ratios. |
|
4090 |
|
4091 @param aAspectRatios |
|
4092 The list of supported pixel aspect ratios. |
|
4093 */ |
|
4094 virtual void MvparGetSupportedPixelAspectRatiosL(RArray<TVideoAspectRatio>& aAspectRatios) = 0; |
|
4095 }; |
|
4096 |
|
4097 |
|
4098 /** |
|
4099 @publishedPartner |
|
4100 @prototype |
|
4101 |
|
4102 Custom command parser class to be used by controller plug-ins wishing to support setting and getting the pixel aspect |
|
4103 ratio for the video recording. |
|
4104 |
|
4105 The controller plug-in should create an object of this type and add it to the list of custom command parsers |
|
4106 in the controller framework. The controller plug-in must be derived from MMMFVideoPixelAspectRatioCustomCommandImplementor |
|
4107 to use this class. |
|
4108 */ |
|
4109 class CMMFVideoPixelAspectRatioCustomCommandParser : public CMMFCustomCommandParserBase |
|
4110 { |
|
4111 public: |
|
4112 |
|
4113 /** |
|
4114 Creates a new custom command parser that supports setting and getting pixel aspect ratio for video recording. |
|
4115 |
|
4116 @param aImplementor |
|
4117 A reference to the controller plug-in that owns this new object. |
|
4118 |
|
4119 @return A pointer to the object created. |
|
4120 |
|
4121 */ |
|
4122 IMPORT_C static CMMFVideoPixelAspectRatioCustomCommandParser* NewL(MMMFVideoPixelAspectRatioCustomCommandImplementor& aImplementor); |
|
4123 |
|
4124 /** |
|
4125 Destructor. |
|
4126 |
|
4127 */ |
|
4128 IMPORT_C ~CMMFVideoPixelAspectRatioCustomCommandParser(); |
|
4129 |
|
4130 /** |
|
4131 Handles a request from the client. Called by the controller framework. |
|
4132 |
|
4133 @param aMessage |
|
4134 The message to be handled. |
|
4135 |
|
4136 */ |
|
4137 void HandleRequest(TMMFMessage& aMessage); |
|
4138 |
|
4139 private: |
|
4140 CMMFVideoPixelAspectRatioCustomCommandParser(MMMFVideoPixelAspectRatioCustomCommandImplementor& aImplementor); |
|
4141 void DoHandleRequestL(TMMFMessage& aMessage); |
|
4142 TBool DoSetPixelAspectRatioL(TMMFMessage& aMessage); |
|
4143 TBool DoGetPixelAspectRatioL(TMMFMessage& aMessage); |
|
4144 TBool DoGetSupportedPixelAspectRatiosL(TMMFMessage& aMessage); |
|
4145 TBool DoCopyArrayDataL(TMMFMessage& aMessage); |
|
4146 void DoCreateBufFromVideoAspectRatioArrayL(RArray<TVideoAspectRatio>& aArray); |
|
4147 |
|
4148 private: |
|
4149 MMMFVideoPixelAspectRatioCustomCommandImplementor& iImplementor; |
|
4150 |
|
4151 CBufFlat* iDataCopyBuffer; |
|
4152 }; |
|
4153 |
|
4154 |
|
4155 /** |
|
4156 @publishedPartner |
|
4157 @prototype |
|
4158 |
|
4159 Client class to allow the audio sampling rate and channels configuration for video recording. |
|
4160 |
|
4161 */ |
|
4162 class RMMFVideoAudioSamplingRateAndChannelConfigCustomCommands : public RMMFCustomCommandsBase |
|
4163 { |
|
4164 public: |
|
4165 |
|
4166 /** |
|
4167 Constructor. |
|
4168 |
|
4169 @param aController |
|
4170 The client side controller object to be used by this custom command interface. |
|
4171 |
|
4172 */ |
|
4173 IMPORT_C RMMFVideoAudioSamplingRateAndChannelConfigCustomCommands(RMMFController& aController); |
|
4174 |
|
4175 /** |
|
4176 Sets the number of audio channels to record (1 for mono, 2 for stereo). |
|
4177 |
|
4178 @param aChannels |
|
4179 The number of audio channels to record. |
|
4180 |
|
4181 @return One of the system-wide error codes. |
|
4182 |
|
4183 */ |
|
4184 IMPORT_C TInt SetAudioChannels(const TUint aChannels); |
|
4185 |
|
4186 /** |
|
4187 Gets the current number of audio channels to record (1 for mono, 2 for stereo). |
|
4188 |
|
4189 @param aChannels |
|
4190 The current number of audio channels to record. |
|
4191 |
|
4192 @return One of the system-wide error codes. |
|
4193 |
|
4194 */ |
|
4195 IMPORT_C TInt GetAudioChannels(TUint& aChannels) const; |
|
4196 |
|
4197 /** |
|
4198 Gets the list of supported number of audio channels for video recording. |
|
4199 |
|
4200 @param aChannels |
|
4201 The supported numbers of audio channels. |
|
4202 |
|
4203 @leave This method may leave with one of the system-wide error codes. |
|
4204 */ |
|
4205 IMPORT_C void GetSupportedAudioChannelsL(RArray<TUint>& aChannels) const; |
|
4206 |
|
4207 /** |
|
4208 Sets the audio sample rate for video recording. |
|
4209 |
|
4210 @param aSampleRate |
|
4211 The sample rate for audio recording. |
|
4212 |
|
4213 @return One of the system-wide error codes. |
|
4214 |
|
4215 */ |
|
4216 IMPORT_C TInt SetAudioSampleRate(const TUint aSampleRate); |
|
4217 |
|
4218 /** |
|
4219 Gets the current audio sample rate for recording. |
|
4220 |
|
4221 @param aSampleRate |
|
4222 The current audio sample rate for recording. |
|
4223 |
|
4224 @return One of the system-wide error codes. |
|
4225 |
|
4226 */ |
|
4227 IMPORT_C TInt GetAudioSampleRate(TUint& aSampleRate) const; |
|
4228 |
|
4229 /** |
|
4230 Gets the list of supported audio sample rates for video recording. |
|
4231 |
|
4232 @param aSampleRates |
|
4233 The supported audio sample rates. |
|
4234 |
|
4235 @leave This method may leave with one of the system-wide error codes. |
|
4236 */ |
|
4237 IMPORT_C void GetSupportedAudioSampleRatesL(RArray<TUint>& aSampleRates) const; |
|
4238 |
|
4239 private: |
|
4240 void DoGetUintArrayL(RArray<TUint>& aArray, TMMFVideoAudioSamplingRateAndChannelConfigMessages aIpc) const; |
|
4241 }; |
|
4242 |
|
4243 |
|
4244 /** |
|
4245 @publishedPartner |
|
4246 @prototype |
|
4247 |
|
4248 Mixin class to be derived from controller plug-ins that could support the audio sampling rate and channels configuration. |
|
4249 */ |
|
4250 class MMMFVideoAudioSamplingRateAndChannelConfigCustomCommandImplementor |
|
4251 { |
|
4252 public: |
|
4253 |
|
4254 /** |
|
4255 Sets the number of audio channels. |
|
4256 |
|
4257 @param aChannels |
|
4258 The number of audio channels to use. |
|
4259 */ |
|
4260 virtual void MvasrccSetAudioChannelsL(const TUint aChannels) = 0; |
|
4261 |
|
4262 /** |
|
4263 Gets the current number of audio channels. |
|
4264 |
|
4265 @param aChannels |
|
4266 The current number of audio channels. |
|
4267 */ |
|
4268 virtual void MvasrccGetAudioChannelsL(TUint& aChannels) = 0; |
|
4269 |
|
4270 /** |
|
4271 Gets the list of supported number of audio channels. |
|
4272 |
|
4273 @param aChannels |
|
4274 The list of supported number of audio channels. |
|
4275 */ |
|
4276 virtual void MvasrccGetSupportedAudioChannelsL(RArray<TUint>& aChannels) = 0; |
|
4277 |
|
4278 /** |
|
4279 Sets the audio sample rate. |
|
4280 |
|
4281 @param aSampleRate |
|
4282 The audio sample rate to use. |
|
4283 */ |
|
4284 virtual void MvasrccSetAudioSampleRateL(const TUint aSampleRate) = 0; |
|
4285 |
|
4286 /** |
|
4287 Gets the current audio sample rate. |
|
4288 |
|
4289 @param aSampleRate |
|
4290 The current audio sample rate. |
|
4291 */ |
|
4292 virtual void MvasrccGetAudioSampleRateL(TUint& aSampleRate) = 0; |
|
4293 |
|
4294 /** |
|
4295 Gets the list of supported audio sample rates. |
|
4296 |
|
4297 @param aSampleRates |
|
4298 The list of supported audio sample rates. |
|
4299 */ |
|
4300 virtual void MvasrccGetSupportedAudioSampleRatesL(RArray<TUint>& aSampleRates) = 0; |
|
4301 }; |
|
4302 |
|
4303 /** |
|
4304 @publishedPartner |
|
4305 @prototype |
|
4306 |
|
4307 Custom command parser class to be used by controller plug-ins wishing to support the audio sampling rate and channels |
|
4308 configuration for the video recording. |
|
4309 |
|
4310 The controller plug-in should create an object of this type and add it to the list of custom command parsers |
|
4311 in the controller framework. The controller plug-in must be derived from MMMFVideoAudioSamplingRateAndChannelConfigCustomCommandImplementor |
|
4312 to use this class. |
|
4313 */ |
|
4314 class CMMFVideoAudioSamplingRateAndChannelConfigCustomCommandParser : public CMMFCustomCommandParserBase |
|
4315 { |
|
4316 public: |
|
4317 |
|
4318 /** |
|
4319 Creates a new custom command parser that supports the audio sampling rate and channels configuration for video recording. |
|
4320 |
|
4321 @param aImplementor |
|
4322 A reference to the controller plug-in that owns this new object. |
|
4323 |
|
4324 @return A pointer to the object created. |
|
4325 |
|
4326 */ |
|
4327 IMPORT_C static CMMFVideoAudioSamplingRateAndChannelConfigCustomCommandParser* NewL(MMMFVideoAudioSamplingRateAndChannelConfigCustomCommandImplementor& aImplementor); |
|
4328 |
|
4329 /** |
|
4330 Destructor. |
|
4331 |
|
4332 */ |
|
4333 IMPORT_C ~CMMFVideoAudioSamplingRateAndChannelConfigCustomCommandParser(); |
|
4334 |
|
4335 /** |
|
4336 Handles a request from the client. Called by the controller framework. |
|
4337 |
|
4338 @param aMessage |
|
4339 The message to be handled. |
|
4340 |
|
4341 */ |
|
4342 void HandleRequest(TMMFMessage& aMessage); |
|
4343 |
|
4344 private: |
|
4345 CMMFVideoAudioSamplingRateAndChannelConfigCustomCommandParser(MMMFVideoAudioSamplingRateAndChannelConfigCustomCommandImplementor& aImplementor); |
|
4346 void DoHandleRequestL(TMMFMessage& aMessage); |
|
4347 TBool DoSetAudioChannelsL(TMMFMessage& aMessage); |
|
4348 TBool DoGetAudioChannelsL(TMMFMessage& aMessage); |
|
4349 TBool DoGetSupportedAudioChannelsL(TMMFMessage& aMessage); |
|
4350 |
|
4351 TBool DoSetAudioSampleRateL(TMMFMessage& aMessage); |
|
4352 TBool DoGetAudioSampleRateL(TMMFMessage& aMessage); |
|
4353 TBool DoGetSupportedAudioSampleRatesL(TMMFMessage& aMessage); |
|
4354 |
|
4355 TBool DoCopyArrayDataL(TMMFMessage& aMessage); |
|
4356 |
|
4357 void DoCreateBufFromUintArrayL(RArray<TUint>& aArray); |
|
4358 |
|
4359 private: |
|
4360 MMMFVideoAudioSamplingRateAndChannelConfigCustomCommandImplementor& iImplementor; |
|
4361 |
|
4362 CBufFlat* iDataCopyBuffer; |
|
4363 }; |
|
4364 |
|
4365 /** |
|
4366 @publishedPartner |
|
4367 @prototype |
|
4368 */ |
|
4369 const TUid KUidInterfaceMMFVideoPlayExt = {0x10283437}; |
|
4370 |
|
4371 /** |
|
4372 Mixin class to be derived from controller plug-ins that could support |
|
4373 play velocity, enabling/disabling audio/video, and auto scaling. |
|
4374 |
|
4375 @publishedPartner |
|
4376 @prototype |
|
4377 */ |
|
4378 class MMMFVideoPlayControllerExtCustomCommandImplementor |
|
4379 { |
|
4380 public: |
|
4381 |
|
4382 /** |
|
4383 Sets play velocity. |
|
4384 Behaviour is same as CVideoPlayerUtility::SetPlayVelocityL |
|
4385 |
|
4386 @see CVideoPlayerUtility::SetPlayVelocityL |
|
4387 */ |
|
4388 virtual void MvpecSetPlayVelocityL(TInt aVelocity)=0; |
|
4389 |
|
4390 /** |
|
4391 Gets play velocity. |
|
4392 Behaviour is same as CVideoPlayerUtility::PlayVelocityL |
|
4393 |
|
4394 @see CVideoPlayerUtility::PlayVelocityL |
|
4395 */ |
|
4396 virtual TInt MvpecPlayVelocityL()=0; |
|
4397 |
|
4398 /** |
|
4399 Steps through frames in pause mode. |
|
4400 Behaviour is same as CVideoPlayerUtility::StepFrameL |
|
4401 |
|
4402 @see CVideoPlayerUtility::StepFrameL |
|
4403 */ |
|
4404 virtual void MvpecStepFrameL(TInt aStep)=0; |
|
4405 |
|
4406 /** |
|
4407 Gets play rate capabilities. |
|
4408 Behaviour is same as CVideoPlayerUtility::GetPlayRateCapabilitiesL |
|
4409 |
|
4410 @see CVideoPlayerUtility::GetPlayRateCapabilitiesL |
|
4411 */ |
|
4412 virtual void MvpecGetPlayRateCapabilitiesL(TVideoPlayRateCapabilities& aCapabilities)=0; |
|
4413 |
|
4414 /** |
|
4415 Enables/Disables video playback. |
|
4416 Behaviour is same as CVideoPlayerUtility::SetVideoEnabledL |
|
4417 |
|
4418 @see CVideoPlayerUtility::SetVideoEnabledL |
|
4419 */ |
|
4420 virtual void MvpecSetVideoEnabledL(TBool aVideoEnabled)=0; |
|
4421 |
|
4422 /** |
|
4423 Queries whether video playback is currently enabled or not. |
|
4424 Behaviour is same as CVideoPlayerUtility::VideoEnabledL |
|
4425 |
|
4426 @see CVideoPlayerUtility::VideoEnabledL |
|
4427 */ |
|
4428 virtual TBool MvpecVideoEnabledL()=0; |
|
4429 |
|
4430 /** |
|
4431 Enables or disables audio playback. |
|
4432 Behaviour is same as CVideoPlayerUtility::SetAudioEnabled |
|
4433 |
|
4434 @see CVideoPlayerUtility::SetAudioEnabled |
|
4435 */ |
|
4436 virtual void MvpecSetAudioEnabledL(TBool aAudioEnabled)=0; |
|
4437 |
|
4438 /** |
|
4439 Sets Auto scale mode. |
|
4440 Behaviour is same as CVideoPlayerUtility::SetAutoScaleL |
|
4441 |
|
4442 @see CVideoPlayerUtility::SetAutoScaleL |
|
4443 */ |
|
4444 virtual void MvpecSetAutoScaleL(TAutoScaleType aScaleType, TInt aHorizPos, TInt aVertPos)=0; |
|
4445 }; |
|
4446 |
|
4447 /** |
|
4448 Used for commands between RMMFVideoPlayControllerExtCustomCommands and |
|
4449 CMMFVideoPlayControllerExtCustomCommandParser classes. |
|
4450 |
|
4451 @internalComponent |
|
4452 */ |
|
4453 enum TMMFVideoPlayControllerExtCustomCommandConfigMessages |
|
4454 { |
|
4455 EMMFVideoPlayControllerSetPlayVelocity = 0, |
|
4456 EMMFVideoPlayControllerPlayVelocity, |
|
4457 EMMFVideoPlayControllerStepFrame, |
|
4458 EMMFVideoPlayControllerGetPlayRateCapabilities, |
|
4459 EMMFVideoPlayControllerSetVideoEnabled, |
|
4460 EMMFVideoPlayControllerVideoEnabled, |
|
4461 EMMFVideoPlayControllerSetAudioEnabled, |
|
4462 EMMFVideoPlayControllerSetAutoScale |
|
4463 }; |
|
4464 /** |
|
4465 @internalComponent |
|
4466 */ |
|
4467 class TMMFVideoPlayAutoScaleParams |
|
4468 { |
|
4469 public: |
|
4470 TAutoScaleType iScaleType; |
|
4471 TInt iHorizPos; |
|
4472 TInt iVertPos; |
|
4473 }; |
|
4474 |
|
4475 /** |
|
4476 Custom command parser class to be used by controller plug-ins wishing to support play velocity, |
|
4477 enabling/disabling audio/video, and auto scaling. |
|
4478 |
|
4479 The controller plug-in should create an object of this type and add it to the list of custom command parsers |
|
4480 in the controller framework. The controller plug-in must be derived from MMMFVideoPlayControllerExtCustomCommandImplementor |
|
4481 to use this class. |
|
4482 |
|
4483 @publishedPartner |
|
4484 @prototype |
|
4485 */ |
|
4486 class CMMFVideoPlayControllerExtCustomCommandParser : public CMMFCustomCommandParserBase |
|
4487 { |
|
4488 public: |
|
4489 |
|
4490 /** |
|
4491 Creates a new custom command parser that supports the video rate control and auto scaling. |
|
4492 |
|
4493 @param aImplementor |
|
4494 A reference to the controller plug-in that owns this new object. |
|
4495 |
|
4496 @return A pointer to the object created. |
|
4497 |
|
4498 */ |
|
4499 IMPORT_C static CMMFVideoPlayControllerExtCustomCommandParser* NewL(MMMFVideoPlayControllerExtCustomCommandImplementor& aImplementor); |
|
4500 |
|
4501 /** |
|
4502 Destructor. |
|
4503 |
|
4504 */ |
|
4505 IMPORT_C ~CMMFVideoPlayControllerExtCustomCommandParser(); |
|
4506 |
|
4507 /** |
|
4508 Handles a request from the client. Called by the controller framework. |
|
4509 |
|
4510 @param aMessage |
|
4511 The message to be handled. |
|
4512 |
|
4513 */ |
|
4514 void HandleRequest(TMMFMessage& aMessage); |
|
4515 |
|
4516 private: |
|
4517 CMMFVideoPlayControllerExtCustomCommandParser(MMMFVideoPlayControllerExtCustomCommandImplementor& aImplementor); |
|
4518 void DoHandleRequestL(TMMFMessage& aMessage); |
|
4519 TBool DoSetPlayVelocityL(TMMFMessage& aMessage); |
|
4520 TBool DoPlayVelocityL(TMMFMessage& aMessage); |
|
4521 TBool DoStepFrameL(TMMFMessage& aMessage); |
|
4522 TBool DoGetPlayRateCapabilitiesL(TMMFMessage& aMessage); |
|
4523 TBool DoSetVideoEnabledL(TMMFMessage& aMessage); |
|
4524 TBool DoVideoEnabledL(TMMFMessage& aMessage); |
|
4525 TBool DoSetAudioEnabledL(TMMFMessage& aMessage); |
|
4526 TBool DoSetAutoScaleL(TMMFMessage& aMessage); |
|
4527 private: |
|
4528 MMMFVideoPlayControllerExtCustomCommandImplementor& iImplementor; |
|
4529 }; |
|
4530 |
|
4531 /** |
|
4532 Resource class to be used by player utility for sending custom commands. |
|
4533 |
|
4534 @publishedPartner |
|
4535 @prototype |
|
4536 */ |
|
4537 class RMMFVideoPlayControllerExtCustomCommands: public RMMFCustomCommandsBase |
|
4538 { |
|
4539 public: |
|
4540 /** |
|
4541 Constructor. |
|
4542 |
|
4543 @param aController |
|
4544 The client side controller object to be used by this custom command interface. |
|
4545 */ |
|
4546 IMPORT_C RMMFVideoPlayControllerExtCustomCommands(RMMFController& aController); |
|
4547 |
|
4548 /** |
|
4549 Sets play velocity. |
|
4550 Behaviour is same as CVideoPlayerUtility::SetPlayVelocityL |
|
4551 |
|
4552 @param aVelocity |
|
4553 Velocity of the playback. |
|
4554 |
|
4555 @return One of the system-wide error codes. |
|
4556 |
|
4557 @see CVideoPlayerUtility::SetPlayVelocityL |
|
4558 */ |
|
4559 IMPORT_C TInt SetPlayVelocity(TInt aVelocity); |
|
4560 |
|
4561 /** |
|
4562 Gets play velocity. |
|
4563 Behaviour is same as CVideoPlayerUtility::PlayVelocityL |
|
4564 |
|
4565 @param aVelocity |
|
4566 Velocity of the playback. |
|
4567 |
|
4568 @return One of the system-wide error codes. |
|
4569 |
|
4570 @see CVideoPlayerUtility::PlayVelocityL |
|
4571 */ |
|
4572 IMPORT_C TInt PlayVelocity(TInt &aVelocity)const; |
|
4573 |
|
4574 /** |
|
4575 Steps through frames in pause mode. |
|
4576 Behaviour is same as CVideoPlayerUtility::StepFrameL |
|
4577 |
|
4578 @param aStep |
|
4579 Count indicating number of frames to step playback position. |
|
4580 |
|
4581 @return One of the system-wide error codes. |
|
4582 |
|
4583 @see CVideoPlayerUtility::StepFrameL |
|
4584 */ |
|
4585 IMPORT_C TInt StepFrame(TInt aStep); |
|
4586 |
|
4587 /** |
|
4588 Gets play rate capabilities. |
|
4589 Behaviour is same as CVideoPlayerUtility::GetPlayRateCapabilitiesL |
|
4590 |
|
4591 @param aCapabilities Playback rate capabilities |
|
4592 |
|
4593 @return One of the system-wide error codes. |
|
4594 |
|
4595 @see CVideoPlayerUtility::GetPlayRateCapabilitiesL |
|
4596 */ |
|
4597 IMPORT_C TInt GetPlayRateCapabilities(TVideoPlayRateCapabilities& aCapabilities)const; |
|
4598 |
|
4599 /** |
|
4600 Enables/Disables video playback. |
|
4601 Behaviour is same as CVideoPlayerUtility::SetVideoEnabledL |
|
4602 |
|
4603 @param aVideoEnabled ETrue to enable video playback, EFalse to disable |
|
4604 |
|
4605 @return One of the system-wide error codes. |
|
4606 |
|
4607 @see CVideoPlayerUtility::SetVideoEnabledL |
|
4608 */ |
|
4609 IMPORT_C TInt SetVideoEnabled(TBool aVideoEnabled); |
|
4610 |
|
4611 /** |
|
4612 Queries whether video playback is currently enabled or not. |
|
4613 Behaviour is same as CVideoPlayerUtility::VideoEnabledL |
|
4614 |
|
4615 @param aVideoEnabled |
|
4616 Out parameter returns ETrue if video playback is enabled, EFalse if not. |
|
4617 |
|
4618 @return One of the system-wide error codes. |
|
4619 |
|
4620 @see CVideoPlayerUtility::VideoEnabledL |
|
4621 */ |
|
4622 IMPORT_C TInt VideoEnabled(TBool &aVideoEnabled)const; |
|
4623 |
|
4624 /** |
|
4625 Enables or disables audio playback. |
|
4626 Behaviour is same as CVideoPlayerUtility::SetAudioEnabledL |
|
4627 |
|
4628 @param aVideoEnabled ETrue to enable audio playback, EFalse to disable |
|
4629 |
|
4630 @return One of the system-wide error codes. |
|
4631 |
|
4632 @see CVideoPlayerUtility::SetAudioEnabledL |
|
4633 */ |
|
4634 IMPORT_C TInt SetAudioEnabled(TBool aAudioEnabled); |
|
4635 |
|
4636 /** |
|
4637 Sets Auto scale mode. |
|
4638 Behaviour is same as CVideoPlayerUtility::SetAutoScaleL |
|
4639 |
|
4640 @param aScaleType Automatic scaling type |
|
4641 @param aHorizPos Video picture horizontal position, relative to the |
|
4642 video window. |
|
4643 @param aVertPos Video picture vertical position, relative to the |
|
4644 video window. |
|
4645 @return One of the system-wide error codes. |
|
4646 |
|
4647 @see CVideoPlayerUtility::SetAutoScaleL |
|
4648 */ |
|
4649 IMPORT_C TInt SetAutoScale(TAutoScaleType aScaleType, TInt aHorizPos, TInt aVertPos); |
|
4650 }; |
|
4651 |
|
4652 /** |
|
4653 @publishedPartner |
|
4654 @prototype |
|
4655 */ |
|
4656 const TUid KUidInterfaceMMFVideoRecorderExt = {0x10283438}; |
|
4657 |
|
4658 /** |
|
4659 Mixin class to be derived from controller plug-ins that could support quality and enabling video. |
|
4660 |
|
4661 @publishedPartner |
|
4662 @prototype |
|
4663 */ |
|
4664 class MMMFVideoRecordControllerExtCustomCommandImplementor |
|
4665 { |
|
4666 public: |
|
4667 |
|
4668 /** |
|
4669 Enabled or disables video in recorder. |
|
4670 Behaviour is same as CVideoRecorderUtility::SetVideoEnabledL |
|
4671 |
|
4672 @see CVideoRecorderUtility::SetVideoEnabledL |
|
4673 */ |
|
4674 virtual void MvrecSetVideoEnabledL(TBool aEnabled)=0; |
|
4675 /** |
|
4676 Gets the flag that indicates video enabled or not. |
|
4677 Behaviour is same as CVideoRecorderUtility::VideoEnabledL |
|
4678 |
|
4679 @see CVideoRecorderUtility::VideoEnabledL |
|
4680 */ |
|
4681 virtual TBool MvrecVideoEnabledL() const=0; |
|
4682 /** |
|
4683 Sets the quality of video being recorded. |
|
4684 Behaviour is same as CVideoRecorderUtility::SetVideoQualityL |
|
4685 |
|
4686 @see CVideoRecorderUtility::SetVideoQualityL |
|
4687 */ |
|
4688 virtual void MvrecSetVideoQualityL(TInt aQuality)=0; |
|
4689 /** |
|
4690 Gets video quality level set using SetVideoQualityL. |
|
4691 Behaviour is same as CVideoRecorderUtility::VideoQualityL |
|
4692 |
|
4693 @see CVideoRecorderUtility::VideoQualityL |
|
4694 */ |
|
4695 virtual TInt MvrecVideoQualityL() const=0; |
|
4696 /** |
|
4697 Sets the video framerate to fixed. |
|
4698 Behaviour is same as CVideoRecorderUtility::SetVideoFrameRateFixedL |
|
4699 |
|
4700 @see CVideoRecorderUtility::SetVideoFrameRateFixedL |
|
4701 */ |
|
4702 virtual void MvrecSetVideoFrameRateFixedL(TBool aFixedFrameRate)=0; |
|
4703 /** |
|
4704 Gets FrameRateFixed flag set using SetVideoFrameRateFixedL. |
|
4705 Behaviour is same as CVideoRecorderUtility::VideoFrameRateFixedL |
|
4706 |
|
4707 @see CVideoRecorderUtility::VideoFrameRateFixedL |
|
4708 */ |
|
4709 virtual TBool MvrecVideoFrameRateFixedL() const=0; |
|
4710 }; |
|
4711 |
|
4712 /** |
|
4713 @internalComponent |
|
4714 */ |
|
4715 enum TMMFVideoRecorderExtCustomCommandConfigMessages |
|
4716 { |
|
4717 EMMFVideoRecordControllerSetVideoEnabled = 0, |
|
4718 EMMFVideoRecordControllerVideoEnabled, |
|
4719 EMMFVideoRecordControllerSetVideoQuality, |
|
4720 EMMFVideoRecordControllerVideoQuality, |
|
4721 EMMFVideoRecordControllerSetVideoFrameRateFixed, |
|
4722 EMMFVideoRecordControllerVideoFrameRateFixed |
|
4723 }; |
|
4724 |
|
4725 /** |
|
4726 Custom command parser class to be used by controller plug-ins wishing to implement VideoRecorderExt custom commands. |
|
4727 |
|
4728 The controller plug-in should create an object of this type and add it to the list of custom command parsers |
|
4729 in the controller framework. The controller plug-in must be derived from MMMFVideoRecordControllerExtCustomCommandImplementor |
|
4730 to use this class. |
|
4731 |
|
4732 @publishedPartner |
|
4733 @prototype |
|
4734 */ |
|
4735 class CMMFVideoRecordControllerExtCustomCommandParser : public CMMFCustomCommandParserBase |
|
4736 { |
|
4737 public: |
|
4738 |
|
4739 /** |
|
4740 Creates a new custom command parser that supports the video rate control and auto scaling. |
|
4741 |
|
4742 @param aImplementor A reference to the controller plug-in that owns this new object. |
|
4743 @return A pointer to the object created. |
|
4744 */ |
|
4745 IMPORT_C static CMMFVideoRecordControllerExtCustomCommandParser* NewL(MMMFVideoRecordControllerExtCustomCommandImplementor& aImplementor); |
|
4746 |
|
4747 /** |
|
4748 Destructor. |
|
4749 */ |
|
4750 IMPORT_C ~CMMFVideoRecordControllerExtCustomCommandParser(); |
|
4751 |
|
4752 /** |
|
4753 Handles a request from the client. Called by the controller framework. |
|
4754 |
|
4755 @param aMessage The message to be handled. |
|
4756 */ |
|
4757 void HandleRequest(TMMFMessage& aMessage); |
|
4758 |
|
4759 private: |
|
4760 CMMFVideoRecordControllerExtCustomCommandParser(MMMFVideoRecordControllerExtCustomCommandImplementor& aImplementor); |
|
4761 void DoHandleRequestL(TMMFMessage& aMessage); |
|
4762 TBool DoSetVideoEnabledL(TMMFMessage& aMessage); |
|
4763 TBool DoVideoEnabledL(TMMFMessage& aMessage); |
|
4764 TBool DoSetVideoQualityL(TMMFMessage& aMessage); |
|
4765 TBool DoVideoQualityL(TMMFMessage& aMessage); |
|
4766 TBool DoSetVideoFrameRateFixedL(TMMFMessage& aMessage); |
|
4767 TBool DoVideoFrameRateFixedL(TMMFMessage& aMessage); |
|
4768 private: |
|
4769 MMMFVideoRecordControllerExtCustomCommandImplementor& iImplementor; |
|
4770 }; |
|
4771 |
|
4772 /** |
|
4773 Resource class to be used by Recorder utility for sending custom commands. |
|
4774 |
|
4775 @publishedPartner |
|
4776 @prototype |
|
4777 */ |
|
4778 class RMMFVideoRecordControllerExtCustomCommands: public RMMFCustomCommandsBase |
|
4779 { |
|
4780 public: |
|
4781 /** |
|
4782 Constructor. |
|
4783 |
|
4784 @param aController |
|
4785 The client side controller object to be used by this custom command interface. |
|
4786 @return One of the system-wide error codes. |
|
4787 */ |
|
4788 IMPORT_C RMMFVideoRecordControllerExtCustomCommands(RMMFController& aController); |
|
4789 |
|
4790 /** |
|
4791 Enabled or disables video in recorder. |
|
4792 Behaviour is same as CVideoRecorderUtility::SetVideoEnabledL |
|
4793 |
|
4794 @param aEnabled ETrue to enable video recording, EFalse to enable it |
|
4795 |
|
4796 @return One of the system-wide error codes. |
|
4797 @see CVideoRecorderUtility::SetVideoEnabledL |
|
4798 */ |
|
4799 IMPORT_C TInt SetVideoEnabled(TBool aEnabled); |
|
4800 |
|
4801 /** |
|
4802 Gets the flag that indicates video enabled or not. |
|
4803 Behaviour is same as CVideoRecorderUtility::VideoEnabledL |
|
4804 |
|
4805 @param aEnabled |
|
4806 Out parameter returns ETrue if video recording is enabled , EFalse otherwise. |
|
4807 |
|
4808 @return One of the system-wide error codes. |
|
4809 @see CVideoRecorderUtility::VideoEnabledL |
|
4810 */ |
|
4811 IMPORT_C TInt VideoEnabled(TBool &aEnabled) const; |
|
4812 |
|
4813 /** |
|
4814 Sets the quality of video being recorded. |
|
4815 Behaviour is same as CVideoRecorderUtility::SetVideoQualityL |
|
4816 |
|
4817 @param aQuality Video quality, in the range of 0 to 100, inclusive. |
|
4818 |
|
4819 @return One of the system-wide error codes. |
|
4820 @see CVideoRecorderUtility::SetVideoQualityL |
|
4821 */ |
|
4822 IMPORT_C TInt SetVideoQuality(TInt aQuality); |
|
4823 |
|
4824 /** |
|
4825 Gets video quality level set using SetVideoQualityL. |
|
4826 Behaviour is same as CVideoRecorderUtility::VideoQualityL |
|
4827 |
|
4828 @param aQuality Out parameter returning Video quality in the range 0-100. |
|
4829 |
|
4830 @return One of the system-wide error codes. |
|
4831 @see CVideoRecorderUtility::VideoQualityL |
|
4832 */ |
|
4833 IMPORT_C TInt VideoQuality(TInt &aQuality) const; |
|
4834 |
|
4835 /** |
|
4836 Sets the video framerate to fixed. |
|
4837 Behaviour is same as CVideoRecorderUtility::SetVideoFrameRateFixedL |
|
4838 |
|
4839 @param aFixedFrameRate ETrue to request a fixed framerate, EFalse to |
|
4840 request a variable framerate. |
|
4841 |
|
4842 @return One of the system-wide error codes. |
|
4843 @see CVideoRecorderUtility::SetVideoFrameRateFixedL |
|
4844 */ |
|
4845 IMPORT_C TInt SetVideoFrameRateFixed(TBool aFixedFrameRate); |
|
4846 |
|
4847 /** |
|
4848 Gets FrameRateFixed flag set using SetVideoFrameRateFixedL. |
|
4849 Behaviour is same as CVideoRecorderUtility::VideoFrameRateFixedL |
|
4850 |
|
4851 @param aFixedFrameRate Out parameter returns ETrue if fixed framerate |
|
4852 is enabled, EFalse otherwise. |
|
4853 |
|
4854 @return One of the system-wide error codes. |
|
4855 @see CVideoRecorderUtility::VideoFrameRateFixedL |
|
4856 */ |
|
4857 IMPORT_C TInt VideoFrameRateFixed(TBool &aFixedFrameRate) const; |
|
4858 }; |
|
4859 |
|
4860 /** |
|
4861 @publishedPartner |
|
4862 @released |
|
4863 |
|
4864 Interface UID and messages for the Audio Play Controller Set Repeats API. |
|
4865 */ |
|
4866 const TUid KUidInterfaceMMFAudioPlaySetRepeatsController = {0x102834D5}; |
|
4867 |
|
4868 /** |
|
4869 @internalComponent |
|
4870 */ |
|
4871 enum TMMFAudioPlayControllerSetRepeatsMessages |
|
4872 { |
|
4873 EMMFAudioPlayControllerSetRepeats |
|
4874 }; |
|
4875 |
|
4876 /** |
|
4877 @publishedPartner |
|
4878 @released |
|
4879 |
|
4880 Client class to access loop play functionality of audio play controller. |
|
4881 |
|
4882 The class uses the custom command function of the controller plugin, and removes the necessity |
|
4883 for the client to formulate the custom commands. |
|
4884 */ |
|
4885 class RMMFAudioPlayControllerSetRepeatsCustomCommands : public RMMFCustomCommandsBase |
|
4886 { |
|
4887 public: |
|
4888 |
|
4889 /** |
|
4890 Constructor. |
|
4891 |
|
4892 @param aController |
|
4893 The client side controller object to be used by this custom command interface. |
|
4894 */ |
|
4895 IMPORT_C RMMFAudioPlayControllerSetRepeatsCustomCommands(RMMFController& aController); |
|
4896 |
|
4897 /** |
|
4898 Sets the number of times the audio sample to be repeated and the trailing silence period |
|
4899 |
|
4900 @param aRepeatNumberOfTimes |
|
4901 The number of times the audio sample needs to be repeated |
|
4902 |
|
4903 @param aTrailingSilence |
|
4904 The time interval of the trailing silence in microseconds. |
|
4905 |
|
4906 @return KErrNotSupported if the controller plugin does not support the loop play functionality. |
|
4907 */ |
|
4908 IMPORT_C TInt SetRepeats(TInt aRepeatNumberOfTimes, const TTimeIntervalMicroSeconds& aTrailingSilence); |
|
4909 }; |
|
4910 |
|
4911 /** |
|
4912 @publishedPartner |
|
4913 @released |
|
4914 |
|
4915 Mixin class to be derived from by controller plugins that could support the set repeats custom command. |
|
4916 */ |
|
4917 class MMMFAudioPlayControllerSetRepeatsCustomCommandImplementor |
|
4918 { |
|
4919 public: |
|
4920 |
|
4921 /** |
|
4922 Sets the number of times the audio sample is to be repeated during the playback operation. |
|
4923 A period of silence can follow each playing of the sample. The audio sample can be repeated indefinitely. |
|
4924 |
|
4925 @param aRepeatNumberOfTimes |
|
4926 The number of times the audio sample, together with the trailing silence, is to be repeated. |
|
4927 If this is set to KMdaRepeatForever, then the audio sample, together with the trailing silence, |
|
4928 is repeated indefinitely or until Stop() is called. |
|
4929 If this is set to zero, then the audio sample is not repeated. |
|
4930 |
|
4931 @param aTrailingSilence |
|
4932 The time interval of the trailing silence in microseconds. |
|
4933 |
|
4934 @return KErrNone if the controller plugin supports the loop play functionality |
|
4935 KErrNotSupported if the controller plugin does not support the loop play functionality |
|
4936 KErrNotReady if the controller plugin is not yet added the audio sink |
|
4937 */ |
|
4938 virtual TInt MapcSetRepeats(TInt aRepeatNumberOfTimes, const TTimeIntervalMicroSeconds& aTrailingSilence) = 0; |
|
4939 }; |
|
4940 |
|
4941 /** |
|
4942 @publishedPartner |
|
4943 @released |
|
4944 |
|
4945 Custom command parser class to be used by controller plugins wishing to support set repeats functionality |
|
4946 |
|
4947 The controller plugin should create an object of this type and add it to the list of custom command parsers |
|
4948 in the controller framework. The controller plugin must be derived from |
|
4949 MMMFAudioPlayControllerSetRepeatsCustomCommandImplementor to use this class. |
|
4950 */ |
|
4951 |
|
4952 class CMMFAudioPlayControllerSetRepeatsCustomCommandParser : public CMMFCustomCommandParserBase |
|
4953 { |
|
4954 public: |
|
4955 |
|
4956 /** |
|
4957 Creates a new custom command parser capable of handling set repeats controller commands. |
|
4958 |
|
4959 @param aImplementor |
|
4960 A reference to the controller plugin that owns this new object. |
|
4961 |
|
4962 @return A pointer to the object created. |
|
4963 |
|
4964 */ |
|
4965 IMPORT_C static CMMFAudioPlayControllerSetRepeatsCustomCommandParser* NewL(MMMFAudioPlayControllerSetRepeatsCustomCommandImplementor& aImplementor); |
|
4966 |
|
4967 /** |
|
4968 Destructor. |
|
4969 |
|
4970 */ |
|
4971 IMPORT_C ~CMMFAudioPlayControllerSetRepeatsCustomCommandParser(); |
|
4972 |
|
4973 /** |
|
4974 Handles a request from the client. Called by the controller framework. |
|
4975 |
|
4976 @param aMessage |
|
4977 The message to be handled. |
|
4978 |
|
4979 */ |
|
4980 void HandleRequest(TMMFMessage& aMessage); |
|
4981 private: |
|
4982 |
|
4983 /** |
|
4984 Constructor. |
|
4985 |
|
4986 @param aImplementor |
|
4987 A reference to the controller plugin that owns this new object. |
|
4988 |
|
4989 */ |
|
4990 CMMFAudioPlayControllerSetRepeatsCustomCommandParser(MMMFAudioPlayControllerSetRepeatsCustomCommandImplementor& aImplementor); |
|
4991 // Internal request handling methods. |
|
4992 void DoHandleRequestL(TMMFMessage& aMessage); |
|
4993 TBool DoSetRepeatsL(TMMFMessage& aMessage); |
|
4994 private: |
|
4995 /** |
|
4996 The object that implements the set repeats custom command i.e controller plugin |
|
4997 */ |
|
4998 MMMFAudioPlayControllerSetRepeatsCustomCommandImplementor& iImplementor; |
|
4999 }; |
|
5000 |
3771 |
5001 #endif |
3772 #endif |