src/kits/media/legacy/OldMediaModule.cpp

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