src/apps/cortex/addons/LoggingConsumer/LoggingConsumer.h

   1 /*
   2  * Copyright 1991-1999, Be Incorporated.
   3  * Copyright (c) 1999-2000, Eric Moon.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions, and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions, and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. The name of the author may not be used to endorse or promote products
  18  *    derived from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
  21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  22  * OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  24  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  25  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  27  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  28  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32
  33 // LoggingConsumer.h
  34
  35 #ifndef LoggingConsumer_H
  36 #define LoggingConsumer_H 1
  37
  38 #include <media/BufferConsumer.h>
  39 #include <media/Controllable.h>
  40 #include <media/MediaEventLooper.h>
  41 #include "LogWriter.h"
  42
  43 // forward declarations
  44 struct entry_ref;
  45 class BTimeSource;
  46 class BMediaAddOn;
  47 class BParameterWeb;
  48 class LogWriter;
  49 struct input_record;
  50
  51 // --------------------
  52 // LoggingConsumer node class
  53
  54 class LoggingConsumer :
  55         public BBufferConsumer,
  56         public BControllable,
  57         public BMediaEventLooper
  58 {
  59 public:
  60         // add-on-friendly ctor
  61         // e.moon [11jun99]
  62         LoggingConsumer(
  63                 const entry_ref& logFile,       // points to an *existing* file
  64                 BMediaAddOn* pAddOn=0);
  65         ~LoggingConsumer();
  66
  67 // Our own logging-control methods
  68         void SetEnabled(log_what what, bool enable);
  69         void EnableAllMessages();
  70         void DisableAllMessages();
  71
  72 // A little bit of instrumentation
  73         long LateBuffers() const { return mLateBuffers; }
  74         void ResetLateBufferCount() { mLateBuffers = 0; }
  75
  76 // Methods from BMediaNode
  77         BMediaAddOn* AddOn(int32*) const;
  78         void SetRunMode(run_mode);
  79         void Preroll();
  80         void SetTimeSource(BTimeSource* time_source);
  81         status_t RequestCompleted(const media_request_info & info);
  82
  83         // e.moon [11jun99; testing add-on]     +++++no longer needed
  84         status_t DeleteHook(BMediaNode* pNode);
  85
  86 // Methods from BControllable
  87         status_t GetParameterValue(
  88                 int32 id,
  89                 bigtime_t* last_change,
  90                 void* value,
  91                 size_t* ioSize);
  92
  93         void SetParameterValue(
  94                 int32 id,
  95                 bigtime_t when,
  96                 const void* value,
  97                 size_t size);
  98
  99 // Methods from BBufferConsumer
 100         status_t HandleMessage(
 101                 int32 message,
 102                 const void* data,
 103                 size_t size );
 104
 105 // all of these are pure virtual in BBufferConsumer
 106         status_t AcceptFormat(
 107                 const media_destination& dest,
 108                 media_format* format);
 109
 110         status_t GetNextInput(
 111                 int32* cookie,
 112                 media_input* out_input);
 113
 114         void DisposeInputCookie( int32 cookie );
 115
 116         void BufferReceived( BBuffer* buffer );
 117
 118         void ProducerDataStatus(
 119                 const media_destination& for_whom,
 120                 int32 status,
 121                 bigtime_t at_performance_time);
 122
 123         status_t GetLatencyFor(
 124                 const media_destination& for_whom,
 125                 bigtime_t* out_latency,
 126                 media_node_id* out_timesource);
 127
 128         status_t Connected(
 129                 const media_source& producer,   /* here's a good place to request buffer group usage */
 130                 const media_destination& where,
 131                 const media_format& with_format,
 132                 media_input* out_input);
 133
 134         void Disconnected(
 135                 const media_source& producer,
 136                 const media_destination& where);
 137
 138         /* The notification comes from the upstream producer, so he's already cool with */
 139         /* the format; you should not ask him about it in here. */
 140         status_t FormatChanged(
 141                 const media_source& producer,
 142                 const media_destination& consumer,
 143                 int32 change_tag,
 144                 const media_format& format);
 145
 146         /* Given a performance time of some previous buffer, retrieve the remembered tag */
 147         /* of the closest (previous or exact) performance time. Set *out_flags to 0; the */
 148         /* idea being that flags can be added later, and the understood flags returned in */
 149         /* *out_flags. */
 150         status_t SeekTagRequested(
 151                 const media_destination& destination,
 152                 bigtime_t in_target_time,
 153                 uint32 in_flags,
 154                 media_seek_tag* out_seek_tag,
 155                 bigtime_t* out_tagged_time,
 156                 uint32* out_flags);
 157
 158 // Methods from BMediaEventLooper
 159
 160         void NodeRegistered();
 161         void Start( bigtime_t performance_time );
 162         void Stop( bigtime_t performance_time, bool immediate );
 163         void Seek( bigtime_t media_time, bigtime_t performance_time );
 164         void TimeWarp( bigtime_t at_real_time, bigtime_t to_performance_time );
 165
 166         // The primary event processing method
 167         void HandleEvent(const media_timed_event *event, bigtime_t lateness, bool realTimeEvent = false);
 168
 169 // Private stuff -- various data we need for the logging implementation and parameter handling
 170 private:
 171         entry_ref mLogRef;                                                              // file that we're logging to
 172         media_input mInput;                                                             // descriptor of our single input
 173         BParameterWeb* mWeb;                                            // description of our controllable parameters
 174         LogWriter* mLogger;                                                             // the actual logging object that we use
 175         bigtime_t mSchedulingLatency;                   // our scheduling latency (estimated at run time)
 176         long mLateBuffers;                                                                      // track how many late buffers we've gotten
 177
 178         // controllable parameters and their change history
 179         bigtime_t mLatency;                                                             // our internal latency
 180         float mSpinPercentage;                                                  // how much of our latency time to spin the CPU
 181         int32 mPriority;                                                                                // our control thread's priority
 182         bigtime_t mLastLatencyChange;                   // when did we last change our latency?
 183         bigtime_t mLastSpinChange;                                      // when did we last change our CPU usage?
 184         bigtime_t mLastPrioChange;                                      // when did we last change thread priority?
 185
 186         // host addon
 187         // [11jun99] e.moon
 188         BMediaAddOn*            m_pAddOn;
 189 };
 190
 191 #endif