1 /*
2 * Copyright 2002, Marcus Overhagen. All Rights Reserved.
3 * Distributed under the terms of the MIT License.
4 */
5
6
7 // This is deprecated API that is not even implemented - no need to export
8 // it on a GCC4 build (BeIDE needs it to run, though, so it's worthwhile for
9 // GCC2)
10 #if __GNUC__ < 3
11
12
13 #include "OldMediaModule.h"
14
15 #include <MediaDebug.h>
16
17
18 /*************************************************************
19 * public BMediaEvent
20 *************************************************************/
21
22 mk_time
Duration()23 BMediaEvent::Duration()
24 {
25 UNIMPLEMENTED();
26
27 return 0;
28 }
29
30
31 bigtime_t
CaptureTime()32 BMediaEvent::CaptureTime()
33 {
34 UNIMPLEMENTED();
35
36 return 0;
37 }
38
39 /*************************************************************
40 * public BEventStream
41 *************************************************************/
42
BEventStream()43 BEventStream::BEventStream()
44 {
45 UNIMPLEMENTED();
46 }
47
48
~BEventStream()49 BEventStream::~BEventStream()
50 {
51 UNIMPLEMENTED();
52 }
53
54
55 mk_time
Start()56 BEventStream::Start()
57 {
58 UNIMPLEMENTED();
59
60 return 0;
61 }
62
63
64 void
SetStart(mk_time)65 BEventStream::SetStart(mk_time)
66 {
67 UNIMPLEMENTED();
68 }
69
70
71 mk_time
Duration()72 BEventStream::Duration()
73 {
74 UNIMPLEMENTED();
75
76 return 0;
77 }
78
79
80 void
SetDuration(mk_time)81 BEventStream::SetDuration(mk_time)
82 {
83 UNIMPLEMENTED();
84 }
85
86
87 status_t
SeekToTime(BMediaChannel * channel,mk_time time)88 BEventStream::SeekToTime(BMediaChannel *channel,
89 mk_time time)
90 {
91 UNIMPLEMENTED();
92
93 return B_ERROR;
94 }
95
96 /*************************************************************
97 * public BMediaRenderer
98 *************************************************************/
99
100
BMediaRenderer(const char * name,int32 priority)101 BMediaRenderer::BMediaRenderer(const char *name,
102 int32 priority)
103 {
104 UNIMPLEMENTED();
105 }
106
107
~BMediaRenderer()108 BMediaRenderer::~BMediaRenderer()
109 {
110 UNIMPLEMENTED();
111 }
112
113
114 char *
Name()115 BMediaRenderer::Name()
116 {
117 UNIMPLEMENTED();
118 return NULL;
119 }
120
121
122 mk_time
Latency()123 BMediaRenderer::Latency()
124 {
125 UNIMPLEMENTED();
126
127 return 0;
128 }
129
130
131 BTransport *
Transport()132 BMediaRenderer::Transport()
133 {
134 UNIMPLEMENTED();
135 return NULL;
136 }
137
138
139 void
SetTransport(BTransport *)140 BMediaRenderer::SetTransport(BTransport *)
141 {
142 UNIMPLEMENTED();
143 }
144
145
146 mk_time
Start()147 BMediaRenderer::Start()
148 {
149 UNIMPLEMENTED();
150
151 return 0;
152 }
153
154
155 mk_time
Duration()156 BMediaRenderer::Duration()
157 {
158 UNIMPLEMENTED();
159
160 return 0;
161 }
162
163
164 BTimeBase *
TimeBase()165 BMediaRenderer::TimeBase()
166 {
167 UNIMPLEMENTED();
168 return NULL;
169 }
170
171
172 void
Open()173 BMediaRenderer::Open()
174 {
175 UNIMPLEMENTED();
176 }
177
178
179 void
Close()180 BMediaRenderer::Close()
181 {
182 UNIMPLEMENTED();
183 }
184
185
186 void
WakeUp()187 BMediaRenderer::WakeUp()
188 {
189 UNIMPLEMENTED();
190 }
191
192
193 void
TransportChanged(mk_time time,mk_rate rate,transport_status status)194 BMediaRenderer::TransportChanged(mk_time time,
195 mk_rate rate,
196 transport_status status)
197 {
198 UNIMPLEMENTED();
199 }
200
201
202 void
StreamChanged()203 BMediaRenderer::StreamChanged()
204 {
205 UNIMPLEMENTED();
206 }
207
208
209 void
OpenReceived()210 BMediaRenderer::OpenReceived()
211 {
212 UNIMPLEMENTED();
213 }
214
215
216 void
CloseReceived()217 BMediaRenderer::CloseReceived()
218 {
219 UNIMPLEMENTED();
220 }
221
222
223 void
WakeUpReceived()224 BMediaRenderer::WakeUpReceived()
225 {
226 UNIMPLEMENTED();
227 }
228
229
230 void
TransportChangedReceived(mk_time time,mk_rate rate,transport_status status)231 BMediaRenderer::TransportChangedReceived(mk_time time,
232 mk_rate rate,
233 transport_status status)
234 {
235 UNIMPLEMENTED();
236 }
237
238
239 void
StreamChangedReceived()240 BMediaRenderer::StreamChangedReceived()
241 {
242 UNIMPLEMENTED();
243 }
244
245 /*************************************************************
246 * private BMediaRenderer
247 *************************************************************/
248
249
250 int32
_LoopThread(void * arg)251 BMediaRenderer::_LoopThread(void *arg)
252 {
253 UNIMPLEMENTED();
254
255 return 0;
256 }
257
258
259 void
LoopThread()260 BMediaRenderer::LoopThread()
261 {
262 UNIMPLEMENTED();
263 }
264
265 /*************************************************************
266 * public BTransport
267 *************************************************************/
268
269
BTransport()270 BTransport::BTransport()
271 {
272 UNIMPLEMENTED();
273 }
274
275
~BTransport()276 BTransport::~BTransport()
277 {
278 UNIMPLEMENTED();
279 }
280
281
282 BTimeBase *
TimeBase()283 BTransport::TimeBase()
284 {
285 UNIMPLEMENTED();
286 return NULL;
287 }
288
289
290 void
SetTimeBase(BTimeBase *)291 BTransport::SetTimeBase(BTimeBase *)
292 {
293 UNIMPLEMENTED();
294 }
295
296
297 BList *
Renderers()298 BTransport::Renderers()
299 {
300 UNIMPLEMENTED();
301 return NULL;
302 }
303
304
305 void
AddRenderer(BMediaRenderer *)306 BTransport::AddRenderer(BMediaRenderer *)
307 {
308 UNIMPLEMENTED();
309 }
310
311
312 bool
RemoveRenderer(BMediaRenderer *)313 BTransport::RemoveRenderer(BMediaRenderer *)
314 {
315 UNIMPLEMENTED();
316
317 return false;
318 }
319
320
321 transport_status
Status()322 BTransport::Status()
323 {
324 UNIMPLEMENTED();
325
326 return B_TRANSPORT_STOPPED;
327 }
328
329
330 void
SetStatus(transport_status)331 BTransport::SetStatus(transport_status)
332 {
333 UNIMPLEMENTED();
334 }
335
336
337 mk_time
PerformanceTime()338 BTransport::PerformanceTime()
339 {
340 UNIMPLEMENTED();
341
342 return 0;
343 }
344
345
346 mk_rate
PerformanceRate()347 BTransport::PerformanceRate()
348 {
349 UNIMPLEMENTED();
350
351 return 0;
352 }
353
354
355 mk_time
TimeOffset()356 BTransport::TimeOffset()
357 {
358 UNIMPLEMENTED();
359
360 return 0;
361 }
362
363
364 void
SetTimeOffset(mk_time)365 BTransport::SetTimeOffset(mk_time)
366 {
367 UNIMPLEMENTED();
368 }
369
370
371 mk_time
MaximumLatency()372 BTransport::MaximumLatency()
373 {
374 UNIMPLEMENTED();
375
376 return 0;
377 }
378
379
380 mk_time
PerformanceStart()381 BTransport::PerformanceStart()
382 {
383 UNIMPLEMENTED();
384
385 return 0;
386 }
387
388
389 mk_time
PerformanceEnd()390 BTransport::PerformanceEnd()
391 {
392 UNIMPLEMENTED();
393
394 return 0;
395 }
396
397
398 void
Open()399 BTransport::Open()
400 {
401 UNIMPLEMENTED();
402 }
403
404
405 void
Close()406 BTransport::Close()
407 {
408 UNIMPLEMENTED();
409 }
410
411
412 void
TransportChanged()413 BTransport::TransportChanged()
414 {
415 UNIMPLEMENTED();
416 }
417
418
419 void
TimeSkipped()420 BTransport::TimeSkipped()
421 {
422 UNIMPLEMENTED();
423 }
424
425
426 void
RequestWakeUp(mk_time,BMediaRenderer *)427 BTransport::RequestWakeUp(mk_time,
428 BMediaRenderer *)
429 {
430 UNIMPLEMENTED();
431 }
432
433
434 void
SeekToTime(mk_time)435 BTransport::SeekToTime(mk_time)
436 {
437 UNIMPLEMENTED();
438 }
439
440
441 BMediaChannel *
GetChannel(int32 selector)442 BTransport::GetChannel(int32 selector)
443 {
444 UNIMPLEMENTED();
445 return NULL;
446 }
447
448 /*************************************************************
449 * public BTimeBase
450 *************************************************************/
451
452
BTimeBase(mk_rate rate)453 BTimeBase::BTimeBase(mk_rate rate)
454 {
455 UNIMPLEMENTED();
456 }
457
458
~BTimeBase()459 BTimeBase::~BTimeBase()
460 {
461 UNIMPLEMENTED();
462 }
463
464
465 BList *
Transports()466 BTimeBase::Transports()
467 {
468 UNIMPLEMENTED();
469 return NULL;
470 }
471
472
473 void
AddTransport(BTransport *)474 BTimeBase::AddTransport(BTransport *)
475 {
476 UNIMPLEMENTED();
477 }
478
479
480 bool
RemoveTransport(BTransport *)481 BTimeBase::RemoveTransport(BTransport *)
482 {
483 UNIMPLEMENTED();
484
485 return false;
486 }
487
488
489 void
TimeSkipped()490 BTimeBase::TimeSkipped()
491 {
492 UNIMPLEMENTED();
493 }
494
495
496 status_t
CallAt(mk_time time,mk_deferred_call function,void * arg)497 BTimeBase::CallAt(mk_time time,
498 mk_deferred_call function,
499 void *arg)
500 {
501 UNIMPLEMENTED();
502
503 return B_ERROR;
504 }
505
506
507 mk_time
Time()508 BTimeBase::Time()
509 {
510 UNIMPLEMENTED();
511
512 return 0;
513 }
514
515
516 mk_rate
Rate()517 BTimeBase::Rate()
518 {
519 UNIMPLEMENTED();
520
521 return 0;
522 }
523
524
525 mk_time
TimeAt(bigtime_t system_time)526 BTimeBase::TimeAt(bigtime_t system_time)
527 {
528 UNIMPLEMENTED();
529
530 return 0;
531 }
532
533
534 bigtime_t
SystemTimeAt(mk_time time)535 BTimeBase::SystemTimeAt(mk_time time)
536 {
537 UNIMPLEMENTED();
538
539 return 0;
540 }
541
542
543 void
Sync(mk_time time,bigtime_t system_time)544 BTimeBase::Sync(mk_time time,
545 bigtime_t system_time)
546 {
547 UNIMPLEMENTED();
548 }
549
550
551 bool
IsAbsolute()552 BTimeBase::IsAbsolute()
553 {
554 UNIMPLEMENTED();
555
556 return false;
557 }
558
559 /*************************************************************
560 * private BTimeBase
561 *************************************************************/
562
563 int32
_SnoozeThread(void * arg)564 BTimeBase::_SnoozeThread(void *arg)
565 {
566 UNIMPLEMENTED();
567
568 return 0;
569 }
570
571
572 void
SnoozeThread()573 BTimeBase::SnoozeThread()
574 {
575 UNIMPLEMENTED();
576 }
577
578 /*************************************************************
579 * public BMediaChannel
580 *************************************************************/
581
BMediaChannel(mk_rate rate,BMediaRenderer * renderer,BEventStream * source)582 BMediaChannel::BMediaChannel(mk_rate rate,
583 BMediaRenderer *renderer,
584 BEventStream *source)
585 {
586 UNIMPLEMENTED();
587 }
588
589
~BMediaChannel()590 BMediaChannel::~BMediaChannel()
591 {
592 UNIMPLEMENTED();
593 }
594
595
596 BMediaRenderer *
Renderer()597 BMediaChannel::Renderer()
598 {
599 UNIMPLEMENTED();
600 return NULL;
601 }
602
603
604 void
SetRenderer(BMediaRenderer *)605 BMediaChannel::SetRenderer(BMediaRenderer *)
606 {
607 UNIMPLEMENTED();
608 }
609
610
611 BEventStream *
Source()612 BMediaChannel::Source()
613 {
614 UNIMPLEMENTED();
615 return NULL;
616 }
617
618
619 void
SetSource(BEventStream *)620 BMediaChannel::SetSource(BEventStream *)
621 {
622 UNIMPLEMENTED();
623 }
624
625
626 mk_rate
Rate()627 BMediaChannel::Rate()
628 {
629 UNIMPLEMENTED();
630
631 return 0;
632 }
633
634
635 void
SetRate(mk_rate)636 BMediaChannel::SetRate(mk_rate)
637 {
638 UNIMPLEMENTED();
639 }
640
641
642 bool
LockChannel()643 BMediaChannel::LockChannel()
644 {
645 UNIMPLEMENTED();
646
647 return false;
648 }
649
650
651 status_t
LockWithTimeout(bigtime_t)652 BMediaChannel::LockWithTimeout(bigtime_t)
653 {
654 UNIMPLEMENTED();
655
656 return B_ERROR;
657 }
658
659
660 void
UnlockChannel()661 BMediaChannel::UnlockChannel()
662 {
663 UNIMPLEMENTED();
664 }
665
666
667 void
StreamChanged()668 BMediaChannel::StreamChanged()
669 {
670 UNIMPLEMENTED();
671 }
672
673
674 #endif // __GNUC__ < 3
675