|
1 /* |
|
2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 // INCLUDE FILES |
|
22 #include <e32base.h> |
|
23 #include <e32std.h> |
|
24 #include <e32def.h> |
|
25 #include <stringpool.h> |
|
26 #include <sdpdocument.h> |
|
27 #include <sdpcodecstringconstants.h> |
|
28 #include <sdpcodecstringpool.h> |
|
29 #include <sdpmediafield.h> |
|
30 #include <sdpattributefield.h> |
|
31 #include <sdprtpmapvalue.h> |
|
32 #include <sdpfmtattributefield.h> |
|
33 #include <sdporiginfield.h> |
|
34 |
|
35 #include "mcemediadefs.h" |
|
36 #include "mcevideosdpcodec.h" |
|
37 #include "mcevideostream.h" |
|
38 #include "mcecomsession.h" |
|
39 #include "mcecomvideostream.h" |
|
40 #include "mcecomvideocodec.h" |
|
41 #include "mceh263codec.h" |
|
42 #include "mcecomfactory.h" |
|
43 #include "mcecomrtpsource.h" |
|
44 #include "mcecomrtpsink.h" |
|
45 #include "mcecomcamerasource.h" |
|
46 #include "mcecomdisplaysink.h" |
|
47 #include "mcemmlogs.h" |
|
48 #include "mcesip.h" |
|
49 |
|
50 |
|
51 |
|
52 const TInt KFrameSizeLength = KMceSdpNumericAttributeLength * 3; |
|
53 |
|
54 |
|
55 // ================= MEMBER FUNCTIONS ======================= |
|
56 |
|
57 // ----------------------------------------------------------------------------- |
|
58 // CMceVideoSdpCodec::NewL |
|
59 // ----------------------------------------------------------------------------- |
|
60 // |
|
61 CMceVideoSdpCodec* CMceVideoSdpCodec::NewL() |
|
62 { |
|
63 RStringF video = MCE_SDP_STRING_VIDEOL(); |
|
64 |
|
65 CMceVideoSdpCodec* self = new (ELeave) CMceVideoSdpCodec( video ); |
|
66 CleanupStack::PushL( self ); |
|
67 self->ConstructL(); |
|
68 CleanupStack::Pop( self ); |
|
69 return self; |
|
70 } |
|
71 |
|
72 // ----------------------------------------------------------------------------- |
|
73 // CMceVideoSdpCodec::CMceVideoSdpCodec |
|
74 // ----------------------------------------------------------------------------- |
|
75 // |
|
76 CMceVideoSdpCodec::CMceVideoSdpCodec( RStringF aMedia ) |
|
77 : CMceMediaSdpCodec( aMedia ) |
|
78 { |
|
79 } |
|
80 |
|
81 |
|
82 // ----------------------------------------------------------------------------- |
|
83 // CMceVideoSdpCodec::ConstructL |
|
84 // ----------------------------------------------------------------------------- |
|
85 // |
|
86 void CMceVideoSdpCodec::ConstructL() |
|
87 { |
|
88 CMceMediaSdpCodec::ConstructL(); |
|
89 |
|
90 iFrameSizeAttr = iStringPool.OpenFStringL( KMceVideoFrameSizeAttribute ); |
|
91 } |
|
92 |
|
93 // ----------------------------------------------------------------------------- |
|
94 // CMceVideoSdpCodec::~CMceVideoSdpCodec |
|
95 // ----------------------------------------------------------------------------- |
|
96 // |
|
97 CMceVideoSdpCodec::~CMceVideoSdpCodec() |
|
98 { |
|
99 iFrameSizeAttr.Close(); |
|
100 } |
|
101 |
|
102 |
|
103 // ----------------------------------------------------------------------------- |
|
104 // CMceVideoSdpCodec::Encodes |
|
105 // ----------------------------------------------------------------------------- |
|
106 // |
|
107 TBool CMceVideoSdpCodec::Encodes( const CMceComMediaStream& aStream ) const |
|
108 { |
|
109 return aStream.iStreamType != CMceComMediaStream::ELocalStream && |
|
110 aStream.iType == KMceVideo; |
|
111 } |
|
112 |
|
113 |
|
114 // ----------------------------------------------------------------------------- |
|
115 // CMceVideoSdpCodec::CodecsL |
|
116 // ----------------------------------------------------------------------------- |
|
117 // |
|
118 const RPointerArray<CMceComCodec>& CMceVideoSdpCodec::CodecsL( CMceComMediaStream& aStream ) const |
|
119 { |
|
120 __ASSERT_ALWAYS( aStream.iType == KMceVideo, User::Leave( KErrArgument ) ); |
|
121 MCE_DEFINE_VIDEO( stream, aStream ); |
|
122 |
|
123 return reinterpret_cast< const RPointerArray< CMceComCodec >& >( stream.Codecs() ); |
|
124 } |
|
125 |
|
126 // ----------------------------------------------------------------------------- |
|
127 // CMceVideoSdpCodec::EncodeRtpmapAttributeLC |
|
128 // ----------------------------------------------------------------------------- |
|
129 // |
|
130 CSdpFmtAttributeField* CMceVideoSdpCodec::EncodeRtpmapAttributeLC( CMceComCodec& aCodec ) const |
|
131 { |
|
132 MCEMM_DEBUG("CMceVideoSdpCodec::EncodeRtpmapAttributeLC(), Entry "); |
|
133 |
|
134 MCE_DEFINE_VIDEO_CODEC( codec, aCodec ); |
|
135 CSdpFmtAttributeField* rtpmapAttribute = NULL; |
|
136 |
|
137 TUint payloadType = codec.iPayloadType; |
|
138 // Get the encoding name |
|
139 TPtrC8 codecName = codec.iSdpName; |
|
140 TUint clockRate = codec.iClockRate; |
|
141 |
|
142 // create rtpmap field for current codec |
|
143 rtpmapAttribute = EncodeRtpMapFieldsL( payloadType, |
|
144 codecName, |
|
145 clockRate, |
|
146 KMceSdpOptionalEncodingParam ); |
|
147 |
|
148 |
|
149 CleanupStack::PushL( rtpmapAttribute ); |
|
150 |
|
151 MCEMM_DEBUG_SVALUE("encoded rtpmap", rtpmapAttribute->Value() ); |
|
152 |
|
153 MCEMM_DEBUG("CMceVideoSdpCodec::EncodeRtpmapAttributeLC(), Exit "); |
|
154 return rtpmapAttribute; |
|
155 |
|
156 |
|
157 } |
|
158 |
|
159 |
|
160 // ----------------------------------------------------------------------------- |
|
161 // CMceVideoSdpCodec::EncodeMediaAttributesL |
|
162 // ----------------------------------------------------------------------------- |
|
163 // |
|
164 void CMceVideoSdpCodec::EncodeMediaAttributesL( CMceComCodec& aCodec, |
|
165 CSdpMediaField& aMediaLine, |
|
166 CSdpFmtAttributeField& aRtpmap ) const |
|
167 { |
|
168 MCEMM_DEBUG("CMceVideoSdpCodec::EncodeMediaAttributesL(), Entry "); |
|
169 MCE_DEFINE_VIDEO_CODEC( codec, aCodec ); |
|
170 |
|
171 EncodeFrameRateAttributeL( codec, aMediaLine, aRtpmap ); |
|
172 EncodeFrameSizeAttributeL( codec, aMediaLine, aRtpmap ); |
|
173 |
|
174 MCEMM_DEBUG("CMceVideoSdpCodec::EncodeMediaAttributesL(), Exit "); |
|
175 } |
|
176 |
|
177 |
|
178 // ----------------------------------------------------------------------------- |
|
179 // CMceVideoSdpCodec::DecodeMediaAttributesL |
|
180 // ----------------------------------------------------------------------------- |
|
181 // |
|
182 |
|
183 void CMceVideoSdpCodec::DecodeMediaAttributesL( |
|
184 CSdpMediaField& aMediaLine, |
|
185 CMceComCodec& aCodec, |
|
186 CSdpFmtAttributeField& /*aRtpmap*/ ) const |
|
187 |
|
188 |
|
189 { |
|
190 MCEMM_DEBUG("CMceVideoSdpCodec::DecodeMediaAttributesL(), Entry "); |
|
191 MCE_DEFINE_VIDEO_CODEC( codec, aCodec ); |
|
192 |
|
193 RPointerArray<CSdpAttributeField>& attrfields = aMediaLine.AttributeFields(); |
|
194 |
|
195 for ( TInt index = 0; index < attrfields.Count(); index++ ) |
|
196 { |
|
197 CSdpAttributeField* attrfield = attrfields[ index ]; |
|
198 RStringF attribute = attrfield->Attribute(); |
|
199 |
|
200 if ( attribute == SDP_STRING( SdpCodecStringConstants::EAttributeFramerate ) ) |
|
201 { |
|
202 const TDesC8& framerate = attrfield->Value(); |
|
203 TReal frameRateVal = ConvertDesToRealL( framerate ); |
|
204 MCEMM_DEBUG_SVALUE("decoded framerate", framerate ); |
|
205 |
|
206 // Do not update frame rate for receive stream, but is anyway good |
|
207 // to know at media side what framerate sender is about to use. |
|
208 TReal& updateFrameRate = codec.Stream()->SendStream() ? |
|
209 codec.iFrameRate : codec.iReceiveFrameRate; |
|
210 |
|
211 updateFrameRate = frameRateVal; |
|
212 } |
|
213 else if ( codec.Stream()->SendStream() && attribute == iFrameSizeAttr ) |
|
214 { |
|
215 const TDesC8& framesize = attrfield->Value(); |
|
216 |
|
217 TInt ind1 = framesize.Locate( KMceSipBlank ); |
|
218 TInt ind2 = framesize.Locate( KMceSipDash ); |
|
219 TInt widthStartPos( ind1 + 1 ); |
|
220 TInt heightStartPos( ind2 + 1 ); |
|
221 |
|
222 if ( ind1 != KErrNotFound && |
|
223 ind2 != KErrNotFound && |
|
224 widthStartPos < ind2 && |
|
225 heightStartPos < framesize.Length() && |
|
226 ConvertDesToUintL( framesize.Mid( 0, ind1 ) ) == |
|
227 codec.iPayloadType ) |
|
228 { |
|
229 codec.iResolutionWidth = |
|
230 ConvertDesToIntL( |
|
231 framesize.Mid( widthStartPos, ind2 - widthStartPos ) ); |
|
232 |
|
233 codec.iResolutionHeight = |
|
234 ConvertDesToIntL( framesize.Mid( heightStartPos ) ); |
|
235 |
|
236 MCEMM_DEBUG_SVALUE("decoded framesize", framesize ); |
|
237 |
|
238 } |
|
239 } |
|
240 else |
|
241 { |
|
242 // NOP |
|
243 } |
|
244 } |
|
245 |
|
246 MCEMM_DEBUG("CMceVideoSdpCodec::DecodeMediaAttributesL(), Exit "); |
|
247 |
|
248 } |
|
249 |
|
250 |
|
251 |
|
252 // ----------------------------------------------------------------------------- |
|
253 // CMceVideoSdpCodec::DecodeSessionMediaAttributesL |
|
254 // ----------------------------------------------------------------------------- |
|
255 // |
|
256 void CMceVideoSdpCodec::DecodeSessionMediaAttributesL( CMceComMediaStream& aStream, |
|
257 CSdpDocument& aSdpDocument ) const |
|
258 { |
|
259 MCEMM_DEBUG("CMceVideoSdpCodec::DecodeSessionMediaAttributesL(), Entry "); |
|
260 MCE_DEFINE_VIDEO( stream, aStream ); |
|
261 |
|
262 RPointerArray<CSdpAttributeField>& attrfields = |
|
263 aSdpDocument.AttributeFields(); |
|
264 |
|
265 const RPointerArray<CMceComVideoCodec>& codecs = stream.Codecs(); |
|
266 // look for the framerate attribute, go through all |
|
267 // attribute fields and apply to all codecs in the stream if found |
|
268 for ( TInt index = 0; index < attrfields.Count(); index++ ) |
|
269 { |
|
270 CSdpAttributeField* attrfield = attrfields[ index ]; |
|
271 RStringF attribute = attrfield->Attribute(); |
|
272 if ( attribute == SDP_STRING( SdpCodecStringConstants::EAttributeFramerate ) ) |
|
273 { |
|
274 TReal frameRate = ConvertDesToRealL( attrfield->Value() ); |
|
275 MCEMM_DEBUG_SVALUE("decoded framerate", attrfield->Value() ); |
|
276 for ( TInt j = 0; j < codecs.Count(); j++ ) |
|
277 { |
|
278 TReal& updateFrameRate = stream.SendStream() ? |
|
279 codecs[ j ]->iFrameRate : codecs[ j ]->iReceiveFrameRate; |
|
280 updateFrameRate = frameRate; |
|
281 } |
|
282 } |
|
283 } |
|
284 |
|
285 MCEMM_DEBUG("CMceVideoSdpCodec::ParseSessionFrameRateAttributeL(), Exit "); |
|
286 |
|
287 } |
|
288 |
|
289 |
|
290 // ----------------------------------------------------------------------------- |
|
291 // CMceVideoSdpCodec::EncodeFrameRateAttributeL |
|
292 // ----------------------------------------------------------------------------- |
|
293 // |
|
294 void CMceVideoSdpCodec::EncodeFrameRateAttributeL( |
|
295 CMceComVideoCodec& aCodec, |
|
296 CSdpMediaField& aMedia, |
|
297 CSdpFmtAttributeField& aFmtpline ) const |
|
298 { |
|
299 MCEMM_DEBUG("CMceVideoSdpCodec::EncodeFrameRateAttributeL(), Entry "); |
|
300 |
|
301 RStringF attributeFrameRate = |
|
302 SDP_STRING( SdpCodecStringConstants::EAttributeFramerate ); |
|
303 |
|
304 HBufC8* frameRate = ConvertTRealToDesLC( aCodec.iFrameRate ); |
|
305 |
|
306 MCEMM_DEBUG_SVALUE("encoded framerate", *frameRate ); |
|
307 |
|
308 CSdpAttributeField* frameRateLine = |
|
309 CSdpAttributeField::NewL( attributeFrameRate, *frameRate ); |
|
310 CleanupStack::PopAndDestroy( frameRate ); |
|
311 CleanupStack::PushL( frameRateLine ); |
|
312 aMedia.AttributeFields().AppendL( frameRateLine ); |
|
313 CleanupStack::Pop( frameRateLine ); |
|
314 |
|
315 |
|
316 // This creates dependency between framerate and payload type |
|
317 frameRateLine->AssignTo( aFmtpline ); |
|
318 |
|
319 MCEMM_DEBUG("CMceVideoSdpCodec::EncodeFrameRateAttributeL(), Exit "); |
|
320 } |
|
321 |
|
322 // ----------------------------------------------------------------------------- |
|
323 // CMceVideoSdpCodec::EncodeFrameSizeAttributeL |
|
324 // ----------------------------------------------------------------------------- |
|
325 // |
|
326 void CMceVideoSdpCodec::EncodeFrameSizeAttributeL( |
|
327 CMceComVideoCodec& aCodec, |
|
328 CSdpMediaField& aMedia, |
|
329 CSdpFmtAttributeField& aFmtpline ) const |
|
330 { |
|
331 MCEMM_DEBUG("CMceVideoSdpCodec::EncodeFrameSizeAttributeL(), Entry "); |
|
332 |
|
333 HBufC8* frameSize = |
|
334 HBufC8::NewLC( KMceVideoFrameSizeFormat().Length() + |
|
335 KFrameSizeLength ); |
|
336 |
|
337 TPtr8 ptrFrameSize( frameSize->Des() ); |
|
338 ptrFrameSize.AppendFormat( KMceVideoFrameSizeFormat, |
|
339 aCodec.iPayloadType, |
|
340 aCodec.iResolutionWidth, |
|
341 aCodec.iResolutionHeight ); |
|
342 |
|
343 MCEMM_DEBUG_SVALUE("encoded framesize", ptrFrameSize ); |
|
344 |
|
345 CSdpAttributeField* frameSizeLine = |
|
346 CSdpAttributeField::NewL( iFrameSizeAttr, *frameSize ); |
|
347 CleanupStack::PopAndDestroy( frameSize ); |
|
348 CleanupStack::PushL( frameSizeLine ); |
|
349 aMedia.AttributeFields().AppendL( frameSizeLine ); |
|
350 CleanupStack::Pop( frameSizeLine ); |
|
351 |
|
352 frameSizeLine->AssignTo( aFmtpline ); |
|
353 |
|
354 MCEMM_DEBUG("CMceVideoSdpCodec::EncodeFrameSizeAttributeL(), Exit "); |
|
355 } |
|
356 |
|
357 // ----------------------------------------------------------------------------- |
|
358 // CMceVideoSdpCodec::CreateStreamLC |
|
359 // ----------------------------------------------------------------------------- |
|
360 // |
|
361 CMceComMediaStream* CMceVideoSdpCodec::CreateStreamLC( TInt aType ) const |
|
362 { |
|
363 MCEMM_DEBUG("CMceVideoSdpCodec::CreateStreamLC(), Entry "); |
|
364 CMceComVideoStream* videostream = NULL; |
|
365 |
|
366 if( aType == SdpCodecStringConstants::EAttributeSendonly ) |
|
367 { |
|
368 // downlink |
|
369 MCEMM_DEBUG( "create downlink" ); |
|
370 videostream = CreateDownlinkStreamL(); |
|
371 } |
|
372 else if( aType == SdpCodecStringConstants::EAttributeRecvonly ) |
|
373 { |
|
374 // uplink |
|
375 MCEMM_DEBUG( "create uplink" ); |
|
376 videostream = CreateUplinkStreamL(); |
|
377 |
|
378 } |
|
379 else |
|
380 { |
|
381 // sendrcv |
|
382 // create two way stream |
|
383 // create downlink |
|
384 MCEMM_DEBUG( "create two-way stream"); |
|
385 videostream = CreateDownlinkStreamL(); |
|
386 CleanupStack::PushL( videostream ); |
|
387 // create bounded uplink |
|
388 CMceComVideoStream *boundUplink = CreateUplinkStreamL(); |
|
389 CleanupStack::PushL( boundUplink ); |
|
390 videostream->BindL( boundUplink ); |
|
391 CleanupStack::Pop( boundUplink ); |
|
392 CleanupStack::Pop( videostream ); |
|
393 } |
|
394 |
|
395 CleanupStack::PushL( videostream ); |
|
396 |
|
397 |
|
398 MCEMM_DEBUG("CMceVideoSdpCodec::CreateStreamLC(), Exit "); |
|
399 return videostream; |
|
400 |
|
401 } |
|
402 |
|
403 |
|
404 // ----------------------------------------------------------------------------- |
|
405 // CMceVideoSdpCodec::UpdateStreamL |
|
406 // ----------------------------------------------------------------------------- |
|
407 // |
|
408 void CMceVideoSdpCodec::UpdateStreamL( CMceComMediaStream& aStream, TInt aDirection ) const |
|
409 { |
|
410 |
|
411 MCEMM_DEBUG("CMceVideoSdpCodec::UpdateStreamL(), Entry "); |
|
412 MCE_DEFINE_VIDEO( stream, aStream ); |
|
413 |
|
414 CMceComVideoStream* videostream = NULL; |
|
415 TInt streamType = stream.SdpStreamType(); |
|
416 |
|
417 if ( aDirection != SdpCodecStringConstants::EAttributeInactive ) |
|
418 { |
|
419 switch( streamType ) |
|
420 { |
|
421 case SdpCodecStringConstants::EAttributeRecvonly: |
|
422 { |
|
423 //if direction is changed |
|
424 if ( aDirection != SdpCodecStringConstants::EAttributeSendonly ) |
|
425 { |
|
426 MCEMM_DEBUG("update from recvonly to send"); |
|
427 MCEMM_DEBUG("create uplink"); |
|
428 videostream = CreateUplinkStreamL(); |
|
429 } |
|
430 break; |
|
431 } |
|
432 case SdpCodecStringConstants::EAttributeSendonly: |
|
433 { |
|
434 //if direction is changed |
|
435 if ( aDirection != SdpCodecStringConstants::EAttributeRecvonly ) |
|
436 { |
|
437 MCEMM_DEBUG("update from sendonly to recv"); |
|
438 MCEMM_DEBUG("create downlink"); |
|
439 videostream = CreateDownlinkStreamL(); |
|
440 } |
|
441 break; |
|
442 } |
|
443 case SdpCodecStringConstants::EAttributeSendrecv: |
|
444 default: |
|
445 { |
|
446 break; |
|
447 } |
|
448 } |
|
449 } |
|
450 |
|
451 if ( videostream ) |
|
452 { |
|
453 CleanupStack::PushL( videostream ); |
|
454 |
|
455 MCEMM_DEBUG("cloning codecs"); |
|
456 |
|
457 for( TInt index = 0; index < stream.CodecCount(); index++ ) |
|
458 { |
|
459 CMceComVideoCodec* codec = |
|
460 static_cast<CMceComVideoCodec*>( stream.CodecL( index )->CloneL() ); |
|
461 CleanupStack::PushL( codec ); |
|
462 MCEMM_DEBUG_SVALUE("cloned codec", codec->iSdpName ); |
|
463 videostream->AddCodecL( codec ); |
|
464 CleanupStack::Pop( codec ); |
|
465 } |
|
466 |
|
467 stream.BindL( videostream ); |
|
468 |
|
469 videostream->InitializeL( *aStream.Session() ); |
|
470 |
|
471 MCEMM_DEBUG("binded stream created"); |
|
472 CleanupStack::Pop( videostream ); |
|
473 |
|
474 |
|
475 } |
|
476 |
|
477 MCEMM_DEBUG("CMceVideoSdpCodec::UpdateStreamL(), Exit "); |
|
478 |
|
479 } |
|
480 |
|
481 // ----------------------------------------------------------------------------- |
|
482 // CMceVideoSdpCodec::CreateCodecLC |
|
483 // ----------------------------------------------------------------------------- |
|
484 // |
|
485 CMceComCodec* CMceVideoSdpCodec::CreateCodecLC( CSdpFmtAttributeField& aRtpmap ) const |
|
486 { |
|
487 MCEMM_DEBUG("CMceVideoSdpCodec::CreateCodecLC(), Entry "); |
|
488 |
|
489 CMceComVideoCodec* codec = NULL; |
|
490 |
|
491 const TDesC8& payloadType = aRtpmap.Format(); |
|
492 const TDesC8& attributeValue = aRtpmap.Value(); |
|
493 TSdpRtpmapValue rtpmapValue = TSdpRtpmapValue::DecodeL( attributeValue ); |
|
494 |
|
495 TPtrC8 codecName = rtpmapValue.iEncName; |
|
496 TPtrC8 clockRate = rtpmapValue.iClockrate; |
|
497 |
|
498 TUint uintValPT = ConvertDesToUintL( payloadType ); |
|
499 TUint uintValCR = ConvertDesToUintL( clockRate ); |
|
500 |
|
501 if ( uintValPT > KMceMaxPTValue ) |
|
502 { |
|
503 MCEMM_DEBUG_DVALUE("CMceVideoSdpCodec::CreateCodecLC(), invalid payloadtype value ", uintValPT ) |
|
504 User::Leave( KErrNotSupported ); |
|
505 } |
|
506 if ( IsSupported( codecName ) ) |
|
507 { |
|
508 TMceComVideoCodecFactory factory; |
|
509 codec = factory.CreateLC( codecName ); |
|
510 codec->iClockRate = uintValCR; |
|
511 codec->iPayloadType = uintValPT; |
|
512 MCEMM_DEBUG_SVALUE("created codec", codecName ); |
|
513 MCEMM_DEBUG_DVALUE("clock rate", uintValCR ) |
|
514 MCEMM_DEBUG_DVALUE("payload", uintValPT ) |
|
515 } |
|
516 else |
|
517 { |
|
518 MCEMM_DEBUG_SVALUE("not supported codec", codecName ); |
|
519 } |
|
520 |
|
521 MCEMM_DEBUG("CMceVideoSdpCodec::CreateCodecLC(), Exit "); |
|
522 |
|
523 return codec; |
|
524 |
|
525 } |
|
526 |
|
527 // ----------------------------------------------------------------------------- |
|
528 // CMceVideoSdpCodec::CreateCodecLC |
|
529 // ----------------------------------------------------------------------------- |
|
530 // |
|
531 CMceComCodec* CMceVideoSdpCodec::CreateCodecLC( TUint aPayload, |
|
532 CSdpMediaField& /*aMediaLine*/ ) const |
|
533 { |
|
534 MCEMM_DEBUG("CMceVideoSdpCodec::CreateCodecLC( payload ), Entry "); |
|
535 |
|
536 TMceComVideoCodecFactory factory; |
|
537 CMceComVideoCodec* codec = NULL; |
|
538 |
|
539 codec = factory.CreateCodecLC( aPayload ); |
|
540 if ( codec && !IsSupported( codec->iSdpName ) ) |
|
541 { |
|
542 CleanupStack::PopAndDestroy( codec ); |
|
543 codec = NULL; |
|
544 } |
|
545 |
|
546 MCEMM_DEBUG("CMceVideoSdpCodec::CreateCodecLC( payload ), Exit "); |
|
547 |
|
548 return codec; |
|
549 } |
|
550 |
|
551 |
|
552 // ----------------------------------------------------------------------------- |
|
553 // CMceVideoSdpCodec::CreateUplinkStreamL |
|
554 // ----------------------------------------------------------------------------- |
|
555 // |
|
556 CMceComVideoStream* CMceVideoSdpCodec::CreateUplinkStreamL() const |
|
557 { |
|
558 MCEMM_DEBUG("CMceVideoSdpCodec::CreateUplinkStreamL(), Entry "); |
|
559 |
|
560 CMceComVideoStream* videoStream = CMceComVideoStream::NewL(); |
|
561 CleanupStack::PushL( videoStream ); |
|
562 // uplink |
|
563 CMceComCameraSource* cameraSource = CMceComCameraSource::NewL(); |
|
564 CleanupStack::PushL( cameraSource ); |
|
565 cameraSource->InitializeL( |
|
566 static_cast<CMceComVideoStream&> ( *videoStream ) ); |
|
567 videoStream->SetSourceL( cameraSource ); |
|
568 CleanupStack::Pop( cameraSource ); |
|
569 CMceComRtpSink* rtpSink = CMceComRtpSink::NewL(); |
|
570 CleanupStack::PushL( rtpSink ); |
|
571 rtpSink->InitializeL( static_cast<CMceComVideoStream&> ( *videoStream ) ); |
|
572 videoStream->AddSinkL( rtpSink ); |
|
573 CleanupStack::Pop( rtpSink ); |
|
574 CleanupStack::Pop( videoStream ); |
|
575 |
|
576 MCEMM_DEBUG("CMceVideoSdpCodec::CreateUplinkStreamL(), Exit "); |
|
577 |
|
578 return videoStream; |
|
579 } |
|
580 |
|
581 // ----------------------------------------------------------------------------- |
|
582 // CMceVideoSdpCodec::CreateDownlinkStreamL |
|
583 // ----------------------------------------------------------------------------- |
|
584 // |
|
585 CMceComVideoStream* CMceVideoSdpCodec::CreateDownlinkStreamL() const |
|
586 { |
|
587 MCEMM_DEBUG("CMceVideoSdpCodec::CreateDownlinkStreamL(), Entry "); |
|
588 |
|
589 CMceComVideoStream* videoStream = CMceComVideoStream::NewL(); |
|
590 CleanupStack::PushL( videoStream ); |
|
591 // downlink |
|
592 CMceComRtpSource* rtpSource = CMceComRtpSource::NewL(); |
|
593 CleanupStack::PushL( rtpSource ); |
|
594 rtpSource->InitializeL( static_cast<CMceComVideoStream&> ( *videoStream ) ); |
|
595 videoStream->SetSourceL( rtpSource ); |
|
596 CleanupStack::Pop( rtpSource ); |
|
597 CMceComDisplaySink* display = CMceComDisplaySink::NewL(); |
|
598 CleanupStack::PushL( display ); |
|
599 display->InitializeL( static_cast<CMceComVideoStream&> ( *videoStream ) ); |
|
600 videoStream->AddSinkL( display ); |
|
601 CleanupStack::Pop( display ); |
|
602 CleanupStack::Pop( videoStream ); |
|
603 |
|
604 MCEMM_DEBUG("CMceVideoSdpCodec::CreateDownlinkStreamL(), Exit "); |
|
605 |
|
606 return videoStream; |
|
607 } |
|
608 |
|
609 |