src/kits/media/legacy/OldAudioModule.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 "OldAudioModule.h"
  14
  15 #include <debug.h>
  16
  17
  18 /*************************************************************
  19  * public BAudioEvent
  20  *************************************************************/
  21
  22 BAudioEvent::BAudioEvent(int32 frames, bool stereo, float *samples)
  23 {
  24         UNIMPLEMENTED();
  25 }
  26
  27
  28 BAudioEvent::~BAudioEvent()
  29 {
  30         UNIMPLEMENTED();
  31 }
  32
  33
  34 mk_time
  35 BAudioEvent::Start()
  36 {
  37         UNIMPLEMENTED();
  38
  39         return 0;
  40 }
  41
  42
  43 void
  44 BAudioEvent::SetStart(mk_time)
  45 {
  46         UNIMPLEMENTED();
  47 }
  48
  49
  50 mk_time
  51 BAudioEvent::Duration()
  52 {
  53         UNIMPLEMENTED();
  54
  55         return 0;
  56 }
  57
  58
  59 int32
  60 BAudioEvent::Frames()
  61 {
  62         UNIMPLEMENTED();
  63
  64         return 0;
  65 }
  66
  67
  68 float *
  69 BAudioEvent::Samples()
  70 {
  71         UNIMPLEMENTED();
  72         return NULL;
  73 }
  74
  75
  76 int32
  77 BAudioEvent::ChannelCount()
  78 {
  79         UNIMPLEMENTED();
  80
  81         return 0;
  82 }
  83
  84
  85 float
  86 BAudioEvent::Gain()
  87 {
  88         UNIMPLEMENTED();
  89
  90         return 0.0f;
  91 }
  92
  93
  94 void
  95 BAudioEvent::SetGain(float)
  96 {
  97         UNIMPLEMENTED();
  98 }
  99
 100
 101 int32
 102 BAudioEvent::Destination()
 103 {
 104         UNIMPLEMENTED();
 105
 106         return 0;
 107 }
 108
 109
 110 void
 111 BAudioEvent::SetDestination(int32)
 112 {
 113         UNIMPLEMENTED();
 114 }
 115
 116
 117 bool
 118 BAudioEvent::MixIn(float *dst, int32 frames, mk_time time)
 119 {
 120         UNIMPLEMENTED();
 121
 122         return false;
 123 }
 124
 125
 126 BMediaEvent *
 127 BAudioEvent::Clone()
 128 {
 129         UNIMPLEMENTED();
 130         return NULL;
 131 }
 132
 133
 134 bigtime_t
 135 BAudioEvent::CaptureTime()
 136 {
 137         UNIMPLEMENTED();
 138
 139         return 0;
 140 }
 141
 142
 143 void
 144 BAudioEvent::SetCaptureTime(bigtime_t)
 145 {
 146         UNIMPLEMENTED();
 147 }
 148
 149
 150 /*************************************************************
 151  * public BDACRenderer
 152  *************************************************************/
 153
 154 BDACRenderer::BDACRenderer(const char *name)
 155 {
 156         UNIMPLEMENTED();
 157 }
 158
 159
 160 BDACRenderer::~BDACRenderer()
 161 {
 162         UNIMPLEMENTED();
 163 }
 164
 165
 166 mk_rate
 167 BDACRenderer::Units()
 168 {
 169         UNIMPLEMENTED();
 170
 171         return 0;
 172 }
 173
 174
 175 mk_time
 176 BDACRenderer::Latency()
 177 {
 178         UNIMPLEMENTED();
 179
 180         return 0;
 181 }
 182
 183
 184 mk_time
 185 BDACRenderer::Start()
 186 {
 187         UNIMPLEMENTED();
 188
 189         return 0;
 190 }
 191
 192
 193 mk_time
 194 BDACRenderer::Duration()
 195 {
 196         UNIMPLEMENTED();
 197
 198         return 0;
 199 }
 200
 201
 202 BTimeBase *
 203 BDACRenderer::TimeBase()
 204 {
 205         UNIMPLEMENTED();
 206         return NULL;
 207 }
 208
 209
 210 void
 211 BDACRenderer::Open()
 212 {
 213         UNIMPLEMENTED();
 214 }
 215
 216
 217 void
 218 BDACRenderer::Close()
 219 {
 220         UNIMPLEMENTED();
 221 }
 222
 223
 224 void
 225 BDACRenderer::Wakeup()
 226 {
 227         UNIMPLEMENTED();
 228 }
 229
 230
 231 void
 232 BDACRenderer::TransportChanged(mk_time time, mk_rate rate,
 233         transport_status status)
 234 {
 235         UNIMPLEMENTED();
 236 }
 237
 238
 239 void
 240 BDACRenderer::StreamChanged()
 241 {
 242         UNIMPLEMENTED();
 243 }
 244
 245
 246 BMediaChannel *
 247 BDACRenderer::Channel()
 248 {
 249         UNIMPLEMENTED();
 250         return NULL;
 251 }
 252
 253 /*************************************************************
 254  * private BDACRenderer
 255  *************************************************************/
 256
 257
 258 bool
 259 BDACRenderer::_WriteDAC(void *arg, char *buf, uint32 bytes, void *header)
 260 {
 261         UNIMPLEMENTED();
 262
 263         return false;
 264 }
 265
 266
 267 bool
 268 BDACRenderer::WriteDAC(short *buf, int32 frames, audio_buffer_header *header)
 269 {
 270         UNIMPLEMENTED();
 271
 272         return false;
 273 }
 274
 275
 276 bool
 277 BDACRenderer::MixActiveSegments(mk_time start)
 278 {
 279         UNIMPLEMENTED();
 280
 281         return false;
 282 }
 283
 284
 285 void
 286 BDACRenderer::MixOutput(short *dst)
 287 {
 288         UNIMPLEMENTED();
 289 }
 290
 291
 292 /*************************************************************
 293  * public BAudioFileStream
 294  *************************************************************/
 295
 296 BAudioFileStream::BAudioFileStream(BMediaChannel *channel, BFile *file,
 297         mk_time start)
 298 {
 299         UNIMPLEMENTED();
 300 }
 301
 302
 303 BAudioFileStream::~BAudioFileStream()
 304 {
 305         UNIMPLEMENTED();
 306 }
 307
 308
 309 BMediaEvent *
 310 BAudioFileStream::GetEvent(BMediaChannel *channel)
 311 {
 312         UNIMPLEMENTED();
 313         return NULL;
 314 }
 315
 316
 317 BMediaEvent *
 318 BAudioFileStream::PeekEvent(BMediaChannel *channel, mk_time asap)
 319 {
 320         UNIMPLEMENTED();
 321         return NULL;
 322 }
 323
 324
 325 status_t
 326 BAudioFileStream::SeekToTime(BMediaChannel *channel, mk_time time)
 327 {
 328         UNIMPLEMENTED();
 329
 330         return B_ERROR;
 331 }
 332
 333
 334 void
 335 BAudioFileStream::SetStart(mk_time start)
 336 {
 337         UNIMPLEMENTED();
 338 }
 339
 340
 341 bigtime_t
 342 BAudioFileStream::CaptureTime()
 343 {
 344         UNIMPLEMENTED();
 345
 346         return 0;
 347 }
 348
 349
 350 BMediaChannel *
 351 BAudioFileStream::Channel()
 352 {
 353         UNIMPLEMENTED();
 354         return NULL;
 355 }
 356
 357 /*************************************************************
 358  * public BADCSource
 359  *************************************************************/
 360
 361 BADCSource::BADCSource(BMediaChannel *channel, mk_time start)
 362         :
 363         fEventLock("BADCSource lock")
 364 {
 365         UNIMPLEMENTED();
 366 }
 367
 368
 369 BADCSource::~BADCSource()
 370 {
 371         UNIMPLEMENTED();
 372 }
 373
 374
 375 BMediaEvent *
 376 BADCSource::GetEvent(BMediaChannel *channel)
 377 {
 378         UNIMPLEMENTED();
 379         return NULL;
 380 }
 381
 382
 383 BMediaEvent *
 384 BADCSource::PeekEvent(BMediaChannel *channel, mk_time asap)
 385 {
 386         UNIMPLEMENTED();
 387         return NULL;
 388 }
 389
 390
 391 status_t
 392 BADCSource::SeekToTime(BMediaChannel *channel, mk_time time)
 393 {
 394         UNIMPLEMENTED();
 395
 396         return B_ERROR;
 397 }
 398
 399
 400 void
 401 BADCSource::SetStart(mk_time start)
 402 {
 403         UNIMPLEMENTED();
 404 }
 405
 406
 407 BMediaChannel *
 408 BADCSource::Channel()
 409 {
 410         UNIMPLEMENTED();
 411         return NULL;
 412 }
 413
 414 /*************************************************************
 415  * private BADCSource
 416  *************************************************************/
 417
 418 bool
 419 BADCSource::_ReadADC(void *arg, char *buf, uint32 bytes, void *header)
 420 {
 421         UNIMPLEMENTED();
 422
 423         return false;
 424 }
 425
 426
 427 void
 428 BADCSource::ReadADC(short *buf, int32 frames, audio_buffer_header *header)
 429 {
 430         UNIMPLEMENTED();
 431 }
 432
 433
 434 #endif  // __GNUC__ < 3