40 using namespace QTMS; |
40 using namespace QTMS; |
41 using namespace TMS; |
41 using namespace TMS; |
42 |
42 |
43 QTMSStream::QTMSStream(void) : |
43 QTMSStream::QTMSStream(void) : |
44 iStream(NULL) |
44 iStream(NULL) |
45 { |
45 { |
46 } |
46 } |
47 |
47 |
48 QTMSStream::~QTMSStream() |
48 QTMSStream::~QTMSStream() |
49 { |
49 { |
50 //delete iStream; |
50 //delete iStream; |
51 //delete (static_cast<QTMSStreamImpl*> (iStream)); |
51 //delete (static_cast<QTMSStreamImpl*> (iStream)); |
52 } |
52 } |
53 |
53 |
54 gint QTMSStream::AddSource(QTMSSource* qsource) |
54 gint QTMSStream::AddSource(QTMSSource* qsource) |
55 { |
55 { |
56 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
56 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
57 |
57 |
58 if (iStream && qsource) |
58 if (iStream && qsource) { |
59 { |
|
60 QTMSSourceType qsrctype; |
59 QTMSSourceType qsrctype; |
61 TMSSource* tmssource(NULL); |
60 TMSSource* tmssource(NULL); |
62 |
61 |
63 qsource->GetType(qsrctype); |
62 qsource->GetType(qsrctype); |
64 |
63 |
65 switch (qsrctype) |
64 switch (qsrctype) { |
66 { |
65 case QTMS_SOURCE_CLIENT: |
67 case QTMS_SOURCE_CLIENT: |
66 status = static_cast<QTMSClientSourceImpl*> (qsource)->GetSource(tmssource); |
68 status = static_cast<QTMSClientSourceImpl*> |
67 break; |
69 (qsource)->GetSource(tmssource); |
68 case QTMS_SOURCE_MODEM: |
70 break; |
69 status = static_cast<QTMSModemSourceImpl*> (qsource)->GetSource(tmssource); |
71 case QTMS_SOURCE_MODEM: |
70 break; |
72 status = static_cast<QTMSModemSourceImpl*> |
71 case QTMS_SOURCE_MIC: |
73 (qsource)->GetSource(tmssource); |
72 status = static_cast<QTMSMicSourceImpl*> (qsource)->GetSource(tmssource); |
74 break; |
73 break; |
75 case QTMS_SOURCE_MIC: |
74 default: |
76 status = static_cast<QTMSMicSourceImpl*> |
75 break; |
77 (qsource)->GetSource(tmssource); |
76 } |
78 break; |
77 if (status == QTMS_RESULT_SUCCESS && tmssource) { |
79 default: |
|
80 break; |
|
81 } |
|
82 if (status == QTMS_RESULT_SUCCESS && tmssource) |
|
83 { |
|
84 status = iStream->AddSource(tmssource); |
78 status = iStream->AddSource(tmssource); |
85 } |
79 } |
86 } |
80 } |
87 return status; |
81 return status; |
88 } |
82 } |
89 |
83 |
90 gint QTMSStream::RemoveSource(QTMSSource* qsource) |
84 gint QTMSStream::RemoveSource(QTMSSource* qsource) |
91 { |
85 { |
92 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
86 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
93 |
87 |
94 if (iStream && qsource) |
88 if (iStream && qsource) { |
95 { |
|
96 QTMSSourceType qsrctype; |
89 QTMSSourceType qsrctype; |
97 TMSSource* tmssource(NULL); |
90 TMSSource* tmssource(NULL); |
98 |
91 |
99 qsource->GetType(qsrctype); |
92 qsource->GetType(qsrctype); |
100 |
93 |
101 switch (qsrctype) |
94 switch (qsrctype) { |
102 { |
95 case QTMS_SOURCE_CLIENT: |
103 case QTMS_SOURCE_CLIENT: |
96 status = static_cast<QTMSClientSourceImpl*> (qsource)->GetSource(tmssource); |
104 status = static_cast<QTMSClientSourceImpl*> |
97 break; |
105 (qsource)->GetSource(tmssource); |
98 case QTMS_SOURCE_MODEM: |
106 break; |
99 status = static_cast<QTMSModemSourceImpl*> (qsource)->GetSource(tmssource); |
107 case QTMS_SOURCE_MODEM: |
100 break; |
108 status = static_cast<QTMSModemSourceImpl*> |
101 case QTMS_SOURCE_MIC: |
109 (qsource)->GetSource(tmssource); |
102 status = static_cast<QTMSMicSourceImpl*> (qsource)->GetSource(tmssource); |
110 break; |
103 break; |
111 case QTMS_SOURCE_MIC: |
104 default: |
112 status = static_cast<QTMSMicSourceImpl*> |
105 break; |
113 (qsource)->GetSource(tmssource); |
106 } |
114 break; |
107 if (status == QTMS_RESULT_SUCCESS && tmssource) { |
115 default: |
|
116 break; |
|
117 } |
|
118 if (status == QTMS_RESULT_SUCCESS && tmssource) |
|
119 { |
|
120 status = iStream->RemoveSource(tmssource); |
108 status = iStream->RemoveSource(tmssource); |
121 } |
109 } |
122 } |
110 } |
123 |
111 |
124 return status; |
112 return status; |
125 } |
113 } |
126 |
114 |
127 gint QTMSStream::AddSink(QTMSSink* qsink) |
115 gint QTMSStream::AddSink(QTMSSink* qsink) |
128 { |
116 { |
129 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
117 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
130 |
118 |
131 if (iStream && qsink) |
119 if (iStream && qsink) { |
132 { |
|
133 QTMSSinkType qsinktype; |
120 QTMSSinkType qsinktype; |
134 TMSSink* tmssink(NULL); |
121 TMSSink* tmssink(NULL); |
135 |
122 |
136 qsink->GetType(qsinktype); |
123 qsink->GetType(qsinktype); |
137 |
124 |
138 switch (qsinktype) |
125 switch (qsinktype) { |
139 { |
126 case QTMS_SINK_CLIENT: |
140 case QTMS_SINK_CLIENT: |
127 status = static_cast<QTMSClientSinkImpl*> (qsink)->GetSink(tmssink); |
141 status = static_cast<QTMSClientSinkImpl*> |
128 break; |
142 (qsink)->GetSink(tmssink); |
129 case QTMS_SINK_MODEM: |
143 break; |
130 status = static_cast<QTMSModemSinkImpl*> (qsink)->GetSink(tmssink); |
144 case QTMS_SINK_MODEM: |
131 break; |
145 status = static_cast<QTMSModemSinkImpl*> |
132 case QTMS_SINK_SPEAKER: |
146 (qsink)->GetSink(tmssink); |
133 status = static_cast<QTMSSpeakerSinkImpl*> (qsink)->GetSink(tmssink); |
147 break; |
134 break; |
148 case QTMS_SINK_SPEAKER: |
135 default: |
149 status = static_cast<QTMSSpeakerSinkImpl*> |
136 break; |
150 (qsink)->GetSink(tmssink); |
137 } |
151 break; |
138 if (status == QTMS_RESULT_SUCCESS && tmssink) { |
152 default: |
|
153 break; |
|
154 } |
|
155 if (status == QTMS_RESULT_SUCCESS && tmssink) |
|
156 { |
|
157 status = iStream->AddSink(tmssink); |
139 status = iStream->AddSink(tmssink); |
158 } |
140 } |
159 } |
141 } |
160 return status; |
142 return status; |
161 } |
143 } |
162 |
144 |
163 gint QTMSStream::RemoveSink(QTMSSink* qsink) |
145 gint QTMSStream::RemoveSink(QTMSSink* qsink) |
164 { |
146 { |
165 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
147 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
166 |
148 |
167 if (iStream && qsink) |
149 if (iStream && qsink) { |
168 { |
|
169 QTMSSinkType qsinktype; |
150 QTMSSinkType qsinktype; |
170 TMSSink* tmssink(NULL); |
151 TMSSink* tmssink(NULL); |
171 |
152 |
172 qsink->GetType(qsinktype); |
153 qsink->GetType(qsinktype); |
173 |
154 |
174 switch (qsinktype) |
155 switch (qsinktype) { |
175 { |
156 case QTMS_SINK_CLIENT: |
176 case QTMS_SINK_CLIENT: |
157 status = static_cast<QTMSClientSinkImpl*> (qsink)->GetSink(tmssink); |
177 status = static_cast<QTMSClientSinkImpl*> |
158 break; |
178 (qsink)->GetSink(tmssink); |
159 case QTMS_SINK_MODEM: |
179 break; |
160 status = static_cast<QTMSModemSinkImpl*> (qsink)->GetSink(tmssink); |
180 case QTMS_SINK_MODEM: |
161 break; |
181 status = static_cast<QTMSModemSinkImpl*> |
162 case QTMS_SINK_SPEAKER: |
182 (qsink)->GetSink(tmssink); |
163 status = static_cast<QTMSSpeakerSinkImpl*> (qsink)->GetSink(tmssink); |
183 break; |
164 break; |
184 case QTMS_SINK_SPEAKER: |
165 default: |
185 status = static_cast<QTMSSpeakerSinkImpl*> |
166 break; |
186 (qsink)->GetSink(tmssink); |
167 } |
187 break; |
168 if (status == QTMS_RESULT_SUCCESS && tmssink) { |
188 default: |
|
189 break; |
|
190 } |
|
191 if (status == QTMS_RESULT_SUCCESS && tmssink) |
|
192 { |
|
193 status = iStream->RemoveSink(tmssink); |
169 status = iStream->RemoveSink(tmssink); |
194 } |
170 } |
195 } |
171 } |
196 |
172 |
197 return status; |
173 return status; |
198 } |
174 } |
199 |
175 |
200 gint QTMSStream::SetFormat(QTMSFormat* qformat) |
176 gint QTMSStream::SetFormat(QTMSFormat* qformat) |
201 { |
177 { |
202 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
178 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
203 |
179 |
204 if (iStream && qformat) |
180 if (iStream && qformat) { |
205 { |
|
206 QTMSFormatType fmttype; |
181 QTMSFormatType fmttype; |
207 TMSFormat* tmsformat(NULL); |
182 TMSFormat* tmsformat(NULL); |
208 qformat->GetType(fmttype); |
183 qformat->GetType(fmttype); |
209 switch (fmttype) |
184 switch (fmttype) { |
210 { |
185 case QTMS_FORMAT_PCM: |
211 case QTMS_FORMAT_PCM: |
186 status = static_cast<QTMSPCMFormatImpl*> (qformat)->GetFormat(tmsformat); |
212 status = static_cast<QTMSPCMFormatImpl*> |
187 break; |
213 (qformat)->GetFormat(tmsformat); |
188 case QTMS_FORMAT_AMR: |
214 break; |
189 status = static_cast<QTMSAMRFormatImpl*> (qformat)->GetFormat(tmsformat); |
215 case QTMS_FORMAT_AMR: |
190 break; |
216 status = static_cast<QTMSAMRFormatImpl*> |
191 case QTMS_FORMAT_G711: |
217 (qformat)->GetFormat(tmsformat); |
192 status = static_cast<QTMSG711FormatImpl*> (qformat)->GetFormat(tmsformat); |
218 break; |
193 break; |
219 case QTMS_FORMAT_G711: |
194 case QTMS_FORMAT_G729: |
220 status = static_cast<QTMSG711FormatImpl*> |
195 status = static_cast<QTMSG729FormatImpl*> (qformat)->GetFormat(tmsformat); |
221 (qformat)->GetFormat(tmsformat); |
196 break; |
222 break; |
197 case QTMS_FORMAT_ILBC: |
223 case QTMS_FORMAT_G729: |
198 status = static_cast<QTMSILBCFormatImpl*> (qformat)->GetFormat(tmsformat); |
224 status = static_cast<QTMSG729FormatImpl*> |
199 break; |
225 (qformat)->GetFormat(tmsformat); |
200 default: |
226 break; |
201 break; |
227 case QTMS_FORMAT_ILBC: |
202 } |
228 status = static_cast<QTMSILBCFormatImpl*> |
|
229 (qformat)->GetFormat(tmsformat); |
|
230 break; |
|
231 default: |
|
232 break; |
|
233 } |
|
234 |
203 |
235 status = iStream->SetFormat(tmsformat); |
204 status = iStream->SetFormat(tmsformat); |
236 } |
205 } |
237 return status; |
206 return status; |
238 } |
207 } |
239 |
208 |
240 gint QTMSStream::ResetFormat(QTMSFormat* qformat) |
209 gint QTMSStream::ResetFormat(QTMSFormat* qformat) |
241 { |
210 { |
242 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
211 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
243 |
212 |
244 if (iStream && qformat) |
213 if (iStream && qformat) { |
245 { |
|
246 QTMSFormatType fmttype; |
214 QTMSFormatType fmttype; |
247 TMSFormat* tmsformat(NULL); |
215 TMSFormat* tmsformat(NULL); |
248 qformat->GetType(fmttype); |
216 qformat->GetType(fmttype); |
249 switch (fmttype) |
217 switch (fmttype) { |
250 { |
218 case QTMS_FORMAT_PCM: |
251 case QTMS_FORMAT_PCM: |
219 status = static_cast<QTMSPCMFormatImpl*> (qformat)->GetFormat(tmsformat); |
252 status = static_cast<QTMSPCMFormatImpl*> |
220 break; |
253 (qformat)->GetFormat(tmsformat); |
221 case QTMS_FORMAT_AMR: |
254 break; |
222 status = static_cast<QTMSAMRFormatImpl*> (qformat)->GetFormat(tmsformat); |
255 case QTMS_FORMAT_AMR: |
223 break; |
256 status = static_cast<QTMSAMRFormatImpl*> |
224 case QTMS_FORMAT_G711: |
257 (qformat)->GetFormat(tmsformat); |
225 status = static_cast<QTMSG711FormatImpl*> (qformat)->GetFormat(tmsformat); |
258 break; |
226 break; |
259 case QTMS_FORMAT_G711: |
227 case QTMS_FORMAT_G729: |
260 status = static_cast<QTMSG711FormatImpl*> |
228 status = static_cast<QTMSG729FormatImpl*> (qformat)->GetFormat(tmsformat); |
261 (qformat)->GetFormat(tmsformat); |
229 break; |
262 break; |
230 case QTMS_FORMAT_ILBC: |
263 case QTMS_FORMAT_G729: |
231 status = static_cast<QTMSILBCFormatImpl*> (qformat)->GetFormat(tmsformat); |
264 status = static_cast<QTMSG729FormatImpl*> |
232 break; |
265 (qformat)->GetFormat(tmsformat); |
233 default: |
266 break; |
234 break; |
267 case QTMS_FORMAT_ILBC: |
235 } |
268 status = static_cast<QTMSILBCFormatImpl*> |
|
269 (qformat)->GetFormat(tmsformat); |
|
270 break; |
|
271 default: |
|
272 break; |
|
273 } |
|
274 |
236 |
275 status = iStream->ResetFormat(tmsformat); |
237 status = iStream->ResetFormat(tmsformat); |
276 } |
238 } |
277 return status; |
239 return status; |
278 } |
240 } |
279 |
241 |
280 gint QTMSStream::AddEffect(QTMSEffect* qeffect) |
242 gint QTMSStream::AddEffect(QTMSEffect* qeffect) |
281 { |
243 { |
282 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
244 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
283 if (iStream && qeffect) |
245 if (iStream && qeffect) { |
284 { |
|
285 QTMSEffectType effecttype; |
246 QTMSEffectType effecttype; |
286 TMSEffect* tmseffect(NULL); |
247 TMSEffect* tmseffect(NULL); |
287 qeffect->GetType(effecttype); |
248 qeffect->GetType(effecttype); |
288 |
249 |
289 switch (effecttype) |
250 switch (effecttype) { |
290 { |
251 case QTMS_EFFECT_VOLUME: |
291 case QTMS_EFFECT_VOLUME: |
252 status = static_cast<QTMSVolumeEffectImpl*> (qeffect)->GetEffect(tmseffect); |
292 status = static_cast<QTMSVolumeEffectImpl*> |
253 break; |
293 (qeffect)->GetEffect(tmseffect); |
254 case QTMS_EFFECT_GAIN: |
294 break; |
255 status = static_cast<QTMSGainEffectImpl*> (qeffect)->GetEffect(tmseffect); |
295 case QTMS_EFFECT_GAIN: |
256 break; |
296 status = static_cast<QTMSGainEffectImpl*> |
257 default: |
297 (qeffect)->GetEffect(tmseffect); |
258 break; |
298 break; |
259 } |
299 default: |
|
300 break; |
|
301 } |
|
302 status = iStream->AddEffect(tmseffect); |
260 status = iStream->AddEffect(tmseffect); |
303 } |
261 } |
304 return status; |
262 return status; |
305 } |
263 } |
306 |
264 |
307 gint QTMSStream::RemoveEffect(QTMSEffect* qeffect) |
265 gint QTMSStream::RemoveEffect(QTMSEffect* qeffect) |
308 { |
266 { |
309 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
267 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
310 if (iStream && qeffect) |
268 if (iStream && qeffect) { |
311 { |
|
312 QTMSEffectType effecttype; |
269 QTMSEffectType effecttype; |
313 TMSEffect* tmseffect(NULL); |
270 TMSEffect* tmseffect(NULL); |
314 qeffect->GetType(effecttype); |
271 qeffect->GetType(effecttype); |
315 |
272 |
316 switch (effecttype) |
273 switch (effecttype) { |
317 { |
274 case QTMS_EFFECT_VOLUME: |
318 case QTMS_EFFECT_VOLUME: |
275 status = static_cast<QTMSVolumeEffectImpl*> (qeffect)->GetEffect(tmseffect); |
319 status = static_cast<QTMSVolumeEffectImpl*> |
276 break; |
320 (qeffect)->GetEffect(tmseffect); |
277 case QTMS_EFFECT_GAIN: |
321 break; |
278 status = static_cast<QTMSGainEffectImpl*> (qeffect)->GetEffect(tmseffect); |
322 case QTMS_EFFECT_GAIN: |
279 break; |
323 status = static_cast<QTMSGainEffectImpl*> |
280 default: |
324 (qeffect)->GetEffect(tmseffect); |
281 break; |
325 break; |
282 } |
326 default: |
|
327 break; |
|
328 } |
|
329 status = iStream->RemoveEffect(tmseffect); |
283 status = iStream->RemoveEffect(tmseffect); |
330 } |
284 } |
331 return status; |
285 return status; |
332 } |
286 } |
333 |
287 |
334 gint QTMSStream::GetState() |
288 gint QTMSStream::GetState() |
335 { |
289 { |
336 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
290 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
337 if (iStream) |
291 if (iStream) { |
338 { |
|
339 status = iStream->GetState(); |
292 status = iStream->GetState(); |
340 } |
293 } |
341 return status; |
294 return status; |
342 } |
295 } |
343 |
296 |
344 gint QTMSStream::GetStreamType() |
297 gint QTMSStream::GetStreamType() |
345 { |
298 { |
346 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
299 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
347 if (iStream) |
300 if (iStream) { |
348 { |
|
349 status = iStream->GetStreamType(); |
301 status = iStream->GetStreamType(); |
350 } |
302 } |
351 return status; |
303 return status; |
352 } |
304 } |
353 |
305 |
354 gint QTMSStream::GetStreamId() |
306 gint QTMSStream::GetStreamId() |
355 { |
307 { |
356 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
308 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
357 if (iStream) |
309 if (iStream) { |
358 { |
|
359 status = iStream->GetStreamId(); |
310 status = iStream->GetStreamId(); |
360 } |
311 } |
361 return status; |
312 return status; |
362 } |
313 } |
363 |
314 |
364 gint QTMSStream::Init(gint retrytime) |
315 gint QTMSStream::Init(gint retrytime) |
365 { |
316 { |
366 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
317 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
367 if (iStream) |
318 if (iStream) { |
368 { |
|
369 status = iStream->Init(retrytime); |
319 status = iStream->Init(retrytime); |
370 } |
320 } |
371 return status; |
321 return status; |
372 } |
322 } |
373 |
323 |
374 gint QTMSStream::Pause() |
324 gint QTMSStream::Pause() |
375 { |
325 { |
376 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
326 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
377 if (iStream) |
327 if (iStream) { |
378 { |
|
379 status = iStream->Pause(); |
328 status = iStream->Pause(); |
380 } |
329 } |
381 return status; |
330 return status; |
382 } |
331 } |
383 |
332 |
384 gint QTMSStream::Start(gint retrytime) |
333 gint QTMSStream::Start(gint retrytime) |
385 { |
334 { |
386 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
335 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
387 if (iStream) |
336 if (iStream) { |
388 { |
|
389 status = iStream->Start(retrytime); |
337 status = iStream->Start(retrytime); |
390 } |
338 } |
391 return status; |
339 return status; |
392 } |
340 } |
393 |
341 |
394 gint QTMSStream::Stop() |
342 gint QTMSStream::Stop() |
395 { |
343 { |
396 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
344 gint status(QTMS_RESULT_UNINITIALIZED_OBJECT); |
397 if (iStream) |
345 if (iStream) { |
398 { |
|
399 status = iStream->Stop(); |
346 status = iStream->Stop(); |
400 } |
347 } |
401 return status; |
348 return status; |
402 } |
349 } |
403 |
350 |
404 void QTMSStream::Deinit() |
351 void QTMSStream::Deinit() |
405 { |
352 { |
406 if (iStream) |
353 if (iStream) { |
407 { |
|
408 iStream->Deinit(); |
354 iStream->Deinit(); |
409 } |
355 } |
410 } |
356 } |
411 |
357 |