ehmry/genode
ehmry/genode
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

use Attached_dataspace at audio streams

Browse Source 
Ref #1987
This commit is contained in:
Emery Hemingway 2017-01-06 15:32:53 +01:00 committed by Norman Feske
parent 1f019d65d3
commit f957fcdd98
11 changed files with 107 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
repos/dde_bsd/src/drivers/audio/main.cc
View File

@ -51,9 +51,9 @@ class Audio_out::Session_component : public Audio_out::Session_rpc_object
public: public:
Session_component(Channel_number channel, Signal_context_capability cap) Session_component(Genode::Env &env, Channel_number channel, Signal_context_capability cap)
: :
Session_rpc_object(cap), _channel(channel) Session_rpc_object(env, cap), _channel(channel)
{ {
Audio_out::channel_acquired[_channel] = this; Audio_out::channel_acquired[_channel] = this;
} }
@ -69,7 +69,7 @@ class Audio_out::Out
{ {
private: private:
Genode::Entrypoint &_ep; Genode::Env &_env;
Genode::Signal_handler<Audio_out::Out> _data_avail_dispatcher; Genode::Signal_handler<Audio_out::Out> _data_avail_dispatcher;
Genode::Signal_handler<Audio_out::Out> _notify_dispatcher; Genode::Signal_handler<Audio_out::Out> _notify_dispatcher;
@ -173,11 +173,11 @@ class Audio_out::Out
public: public:
Out(Genode::Entrypoint &ep) Out(Genode::Env &env)
: :
_ep(ep), _env(env),
_data_avail_dispatcher(ep, *this, &Audio_out::Out::_handle_data_avail), _data_avail_dispatcher(env.ep(), *this, &Audio_out::Out::_handle_data_avail),
_notify_dispatcher(ep, *this, &Audio_out::Out::_handle_notify) _notify_dispatcher(env.ep(), *this, &Audio_out::Out::_handle_notify)
{ {
/* play a silence packet to get the driver running */ /* play a silence packet to get the driver running */
_play_silence(); _play_silence();
@ -262,7 +262,7 @@ class Audio_out::Root : public Audio_out::Root_component
{ {
private: private:
Genode::Entrypoint &_ep; Genode::Env &_env;
Signal_context_capability _cap; Signal_context_capability _cap;
@ -278,16 +278,16 @@ class Audio_out::Root : public Audio_out::Root_component
Out::channel_number(channel_name, &channel_number); Out::channel_number(channel_name, &channel_number);
return new (md_alloc()) return new (md_alloc())
Session_component(channel_number, _cap); Session_component(_env, channel_number, _cap);
} }
public: public:
Root(Genode::Entrypoint &ep, Allocator &md_alloc, Root(Genode::Env &env, Allocator &md_alloc,
Signal_context_capability cap) Signal_context_capability cap)
: :
Root_component(&ep.rpc_ep(), &md_alloc), Root_component(env.ep(), md_alloc),
_ep(ep), _cap(cap) _env(env), _cap(cap)
{ } { }
}; };
@ -315,9 +315,9 @@ class Audio_in::Session_component : public Audio_in::Session_rpc_object
public: public:
Session_component(Channel_number channel, Session_component(Genode::Env &env, Channel_number channel,
Genode::Signal_context_capability cap) Genode::Signal_context_capability cap)
: Session_rpc_object(cap), _channel(channel) { : Session_rpc_object(env, cap), _channel(channel) {
channel_acquired = this; } channel_acquired = this; }
~Session_component() { channel_acquired = nullptr; } ~Session_component() { channel_acquired = nullptr; }
@ -328,7 +328,7 @@ class Audio_in::In
{ {
private: private:
Genode::Entrypoint &_ep; Genode::Env &_env;
Genode::Signal_handler<Audio_in::In> _notify_dispatcher; Genode::Signal_handler<Audio_in::In> _notify_dispatcher;
bool _active() { return channel_acquired && channel_acquired->active(); } bool _active() { return channel_acquired && channel_acquired->active(); }
@ -375,10 +375,10 @@ class Audio_in::In
public: public:
In(Genode::Entrypoint &ep) In(Genode::Env &env)
: :
_ep(ep), _env(env),
_notify_dispatcher(ep, *this, &Audio_in::In::_handle_notify) _notify_dispatcher(env.ep(), *this, &Audio_in::In::_handle_notify)
{ _record_packet(); } { _record_packet(); }
Signal_context_capability sigh() { return _notify_dispatcher; } Signal_context_capability sigh() { return _notify_dispatcher; }
@ -453,7 +453,7 @@ class Audio_in::Root : public Audio_in::Root_component
{ {
private: private:
Genode::Entrypoint &_ep; Genode::Env &_env;
Signal_context_capability _cap; Signal_context_capability _cap;
protected: protected:
@ -466,14 +466,14 @@ class Audio_in::Root : public Audio_in::Root_component
sizeof(channel_name), sizeof(channel_name),
"left"); "left");
In::channel_number(channel_name, &channel_number); In::channel_number(channel_name, &channel_number);
return new (md_alloc()) Session_component(channel_number, _cap); return new (md_alloc()) Session_component(_env, channel_number, _cap);
} }
public: public:
Root(Genode::Entrypoint &ep, Allocator &md_alloc, Root(Genode::Env &env, Allocator &md_alloc,
Signal_context_capability cap) Signal_context_capability cap)
: Root_component(&ep.rpc_ep(), &md_alloc), _ep(ep), _cap(cap) { } : Root_component(env.ep(), md_alloc), _env(env), _cap(cap) { }
}; };
@ -484,13 +484,12 @@ class Audio_in::Root : public Audio_in::Root_component
struct Main struct Main
{ {
Genode::Env &env; Genode::Env &env;
Genode::Entrypoint &ep;
Genode::Heap heap { &env.ram(), &env.rm() }; Genode::Heap heap { &env.ram(), &env.rm() };
Genode::Attached_rom_dataspace config { env, "config" }; Genode::Attached_rom_dataspace config { env, "config" };
Genode::Signal_handler<Main> config_update_dispatcher { Genode::Signal_handler<Main> config_update_dispatcher {
ep, *this, &Main::handle_config_update }; env.ep(), *this, &Main::handle_config_update };
void handle_config_update() void handle_config_update()
{ {
@ -499,7 +498,7 @@ struct Main
Audio::update_config(config.xml()); Audio::update_config(config.xml());
} }
Main(Genode::Env &env) : env(env), ep(env.ep()) Main(Genode::Env &env) : env(env)
{ {
Audio::init_driver(env, heap, config.xml()); Audio::init_driver(env, heap, config.xml());
@ -509,21 +508,21 @@ struct Main
/* playback */ /* playback */
if (config.xml().attribute_value("playback", true)) { if (config.xml().attribute_value("playback", true)) {
static Audio_out::Out out(ep); static Audio_out::Out out(env);
Audio::play_sigh(out.sigh()); Audio::play_sigh(out.sigh());
static Audio_out::Root out_root(ep, heap, out.data_avail()); static Audio_out::Root out_root(env, heap, out.data_avail());
env.parent().announce(ep.manage(out_root)); env.parent().announce(env.ep().manage(out_root));
Genode::log("--- BSD Audio driver enable playback ---"); Genode::log("--- BSD Audio driver enable playback ---");
} }
/* recording */ /* recording */
if (config.xml().attribute_value("recording", true)) { if (config.xml().attribute_value("recording", true)) {
static Audio_in::In in(ep); static Audio_in::In in(env);
Audio::record_sigh(in.sigh()); Audio::record_sigh(in.sigh());
static Audio_in::Root in_root(ep, heap, static Audio_in::Root in_root(env, heap,
Genode::Signal_context_capability()); Genode::Signal_context_capability());
env.parent().announce(ep.manage(in_root)); env.parent().announce(env.ep().manage(in_root));
Genode::log("--- BSD Audio driver enable recording ---"); Genode::log("--- BSD Audio driver enable recording ---");
} }

45
repos/dde_bsd/src/test/audio_in/main.cc
View File

@ -7,7 +7,7 @@
*/ */
/* /*
* Copyright (C) 2015 Genode Labs GmbH * Copyright (C) 2015-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -16,10 +16,10 @@
/* Genode includes */ /* Genode includes */
#include <audio_out_session/connection.h> #include <audio_out_session/connection.h>
#include <audio_in_session/connection.h> #include <audio_in_session/connection.h>
#include <base/component.h>
#include <base/heap.h>
#include <base/log.h> #include <base/log.h>
#include <base/sleep.h>
#include <dataspace/client.h> #include <dataspace/client.h>
#include <os/config.h>
#include <rom_session/connection.h> #include <rom_session/connection.h>
@ -36,12 +36,11 @@ class Recording
{ {
private: private:
Genode::Signal_receiver &_sig_rec; Genode::Signal_handler<Recording> _record_progress;
Genode::Signal_dispatcher<Recording> _record_progress; Genode::Signal_handler<Recording> _record_overrun;
Genode::Signal_dispatcher<Recording> _record_overrun;
Audio_out::Connection *_audio_out[CHANNELS]; Audio_out::Connection *_audio_out[CHANNELS];
Audio_in::Connection _audio_in { "left" }; Audio_in::Connection _audio_in;
Audio_in::Stream &_stream; Audio_in::Stream &_stream;
void _play(Audio_in::Packet *ip) void _play(Audio_in::Packet *ip)
@ -68,7 +67,7 @@ class Recording
_audio_out[c]->submit(op[c]); _audio_out[c]->submit(op[c]);
} }
void _handle_record_progress(unsigned) void _handle_record_progress()
{ {
Audio_in::Packet *p = _stream.get(_stream.pos()); Audio_in::Packet *p = _stream.get(_stream.pos());
@ -83,7 +82,7 @@ class Recording
_stream.increment_position(); _stream.increment_position();
} }
void _handle_record_overrun(unsigned) void _handle_record_overrun()
{ {
unsigned pos = _stream.pos(); unsigned pos = _stream.pos();
unsigned tail = _stream.tail(); unsigned tail = _stream.tail();
@ -101,11 +100,11 @@ class Recording
public: public:
Recording(Genode::Allocator &md_alloc, Genode::Signal_receiver &sig_rec) Recording(Genode::Env &env, Genode::Allocator &md_alloc)
: :
_sig_rec(sig_rec), _record_progress(env.ep(), *this, &Recording::_handle_record_progress),
_record_progress(_sig_rec, *this, &Recording::_handle_record_progress), _record_overrun(env.ep(), *this, &Recording::_handle_record_overrun),
_record_overrun(_sig_rec, *this, &Recording::_handle_record_overrun), _audio_in(env, "left" ),
_stream(*_audio_in.stream()) _stream(*_audio_in.stream())
{ {
_audio_in.progress_sigh(_record_progress); _audio_in.progress_sigh(_record_progress);
@ -121,24 +120,10 @@ class Recording
} }
}; };
int main(int argc, char *argv[]) void Component::construct(Genode::Env &env)
{ {
Genode::log("--- Audio_in test ---"); Genode::log("--- Audio_in test ---");
using namespace Genode; static Genode::Heap heap { env.ram(), env.rm() };
static Recording record(env, heap);
Signal_receiver sig_rec;
Recording record(*env()->heap(), sig_rec);
for (;;) {
Signal sig = sig_rec.wait_for_signal();
Signal_dispatcher_base *dispatcher =
dynamic_cast<Signal_dispatcher_base *>(sig.context());
if (dispatcher)
dispatcher->dispatch(sig.num());
}
return 0;
} }

10
repos/os/include/audio_in_session/client.h
View File

@ -17,6 +17,7 @@
/* Genode includes */ /* Genode includes */
#include <base/env.h> #include <base/env.h>
#include <base/rpc_client.h> #include <base/rpc_client.h>
#include <base/attached_dataspace.h>
#include <audio_in_session/audio_in_session.h> #include <audio_in_session/audio_in_session.h>
@ -43,6 +44,8 @@ class Audio_in::Session_client : public Genode::Rpc_client<Session>
{ {
private: private:
Genode::Attached_dataspace _shared_ds;
Signal _progress; Signal _progress;
Genode::Signal_transmitter _data_avail; Genode::Signal_transmitter _data_avail;
@ -55,14 +58,15 @@ class Audio_in::Session_client : public Genode::Rpc_client<Session>
* \param session session capability * \param session session capability
* \param progress_signal true, install 'progress_signal' receiver * \param progress_signal true, install 'progress_signal' receiver
*/ */
Session_client(Genode::Capability<Session> session, Session_client(Genode::Region_map &rm,
Genode::Capability<Session> session,
bool progress_signal) bool progress_signal)
: :
Genode::Rpc_client<Session>(session), Genode::Rpc_client<Session>(session),
_shared_ds(rm, call<Rpc_dataspace>()),
_data_avail(call<Rpc_data_avail_sigh>()) _data_avail(call<Rpc_data_avail_sigh>())
{ {
/* ask server for stream data space and attach it */ _stream = _shared_ds.local_addr<Stream>();
_stream = static_cast<Stream *>(Genode::env()->rm_session()->attach(call<Rpc_dataspace>()));
if (progress_signal) if (progress_signal)
progress_sigh(_progress.cap); progress_sigh(_progress.cap);

15
repos/os/include/audio_in_session/connection.h
View File

@ -44,20 +44,7 @@ struct Audio_in::Connection : Genode::Connection<Session>, Audio_in::Session_cli
Connection(Genode::Env &env, char const *channel, bool progress_signal = false) Connection(Genode::Env &env, char const *channel, bool progress_signal = false)
: :
Genode::Connection<Session>(env, _session(env.parent(), channel)), Genode::Connection<Session>(env, _session(env.parent(), channel)),
Session_client(cap(), progress_signal) Session_client(env.rm(), cap(), progress_signal)
{ }
/**
* Constructor
*
* \noapi
* \deprecated Use the constructor with 'Env &' as first
* argument instead
*/
Connection(char const *channel, bool progress_signal = false)
:
Genode::Connection<Session>(_session(*Genode::env()->parent(), channel)),
Session_client(cap(), progress_signal)
{ } { }
}; };

26
repos/os/include/audio_in_session/rpc_object.h
View File

@ -17,6 +17,7 @@
/* Genode includes */ /* Genode includes */
#include <base/env.h> #include <base/env.h>
#include <base/rpc_server.h> #include <base/rpc_server.h>
#include <base/attached_ram_dataspace.h>
#include <audio_in_session/audio_in_session.h> #include <audio_in_session/audio_in_session.h>
@ -28,31 +29,22 @@ class Audio_in::Session_rpc_object : public Genode::Rpc_object<Audio_in::Session
{ {
protected: protected:
bool _stopped; /* state */ Genode::Attached_ram_dataspace _ds; /* contains Audio_in stream */
Genode::Ram_dataspace_capability _ds; /* contains Audio_in stream */
Genode::Signal_context_capability _data_cap; Genode::Signal_context_capability _data_cap;
Genode::Signal_context_capability _progress_cap; Genode::Signal_context_capability _progress_cap;
Genode::Signal_context_capability _overrun_cap; Genode::Signal_context_capability _overrun_cap;
bool _stopped; /* state */
public: public:
Session_rpc_object(Genode::Signal_context_capability data_cap) Session_rpc_object(Genode::Env &env, Genode::Signal_context_capability data_cap)
: :
_stopped(true), _data_cap(data_cap) _ds(env.ram(), env.rm(), sizeof(Stream)),
_data_cap(data_cap), _stopped(true)
{ {
using namespace Genode; _stream = _ds.local_addr<Stream>();
_ds = env()->ram_session()->alloc(sizeof(Stream));
_stream = static_cast<Stream *>(env()->rm_session()->attach(_ds));
}
virtual ~Session_rpc_object()
{
if (_ds.valid()) {
Genode::env()->rm_session()->detach(_stream);
Genode::env()->ram_session()->free(_ds);
}
} }
@ -77,7 +69,7 @@ class Audio_in::Session_rpc_object : public Genode::Rpc_object<Audio_in::Session
void start() { _stopped = false; } void start() { _stopped = false; }
void stop() { _stopped = true; } void stop() { _stopped = true; }
Genode::Dataspace_capability dataspace() { return _ds; } Genode::Dataspace_capability dataspace() { return _ds.cap(); }
/********************************** /**********************************

13
repos/os/include/audio_out_session/client.h
View File

@ -16,6 +16,7 @@
#include <base/env.h> #include <base/env.h>
#include <base/rpc_client.h> #include <base/rpc_client.h>
#include <base/attached_dataspace.h>
#include <audio_out_session/audio_out_session.h> #include <audio_out_session/audio_out_session.h>
namespace Audio_out { namespace Audio_out {
@ -41,6 +42,8 @@ class Audio_out::Session_client : public Genode::Rpc_client<Session>
{ {
private: private:
Genode::Attached_dataspace _shared_ds;
Signal _progress; Signal _progress;
Signal _alloc; Signal _alloc;
@ -51,18 +54,20 @@ class Audio_out::Session_client : public Genode::Rpc_client<Session>
/** /**
* Constructor * Constructor
* *
* \param rm region map for attaching shared buffer
* \param session session capability * \param session session capability
* \param alloc_signal true, install 'alloc_signal' receiver * \param alloc_signal true, install 'alloc_signal' receiver
* \param progress_signal true, install 'progress_signal' receiver * \param progress_signal true, install 'progress_signal' receiver
*/ */
Session_client(Genode::Capability<Session> session, bool alloc_signal, Session_client(Genode::Region_map &rm,
bool progress_signal) Genode::Capability<Session> session,
bool alloc_signal, bool progress_signal)
: :
Genode::Rpc_client<Session>(session), Genode::Rpc_client<Session>(session),
_shared_ds(rm, call<Rpc_dataspace>()),
_data_avail(call<Rpc_data_avail_sigh>()) _data_avail(call<Rpc_data_avail_sigh>())
{ {
/* ask server for stream data space and attach it */ _stream = _shared_ds.local_addr<Stream>();
_stream = static_cast<Stream *>(Genode::env()->rm_session()->attach(call<Rpc_dataspace>()));
if (progress_signal) if (progress_signal)
progress_sigh(_progress.cap); progress_sigh(_progress.cap);

4
repos/os/include/audio_out_session/connection.h
View File

@ -50,7 +50,7 @@ struct Audio_out::Connection : Genode::Connection<Session>, Audio_out::Session_c
bool progress_signal = false) bool progress_signal = false)
: :
Genode::Connection<Session>(env, _session(env.parent(), channel)), Genode::Connection<Session>(env, _session(env.parent(), channel)),
Session_client(cap(), alloc_signal, progress_signal) Session_client(env.rm(), cap(), alloc_signal, progress_signal)
{ } { }
/** /**
@ -65,7 +65,7 @@ struct Audio_out::Connection : Genode::Connection<Session>, Audio_out::Session_c
bool progress_signal = false) bool progress_signal = false)
: :
Genode::Connection<Session>(_session(*Genode::env()->parent(), channel)), Genode::Connection<Session>(_session(*Genode::env()->parent(), channel)),
Session_client(cap(), alloc_signal, progress_signal) Session_client(*Genode::env()->rm_session(), cap(), alloc_signal, progress_signal)
{ } { }
}; };

29
repos/os/include/audio_out_session/rpc_object.h
View File

@ -16,6 +16,7 @@
#include <base/env.h> #include <base/env.h>
#include <base/rpc_server.h> #include <base/rpc_server.h>
#include <base/attached_ram_dataspace.h>
#include <audio_out_session/audio_out_session.h> #include <audio_out_session/audio_out_session.h>
@ -27,33 +28,25 @@ class Audio_out::Session_rpc_object : public Genode::Rpc_object<Audio_out::Sessi
{ {
protected: protected:
bool _stopped; /* state */ Genode::Attached_ram_dataspace _ds; /* contains Audio_out stream */
Genode::Ram_dataspace_capability _ds; /* contains Audio_out_stream */ Genode::Signal_transmitter _progress;
Genode::Signal_transmitter _progress; Genode::Signal_transmitter _alloc;
Genode::Signal_transmitter _alloc;
Genode::Signal_context_capability _data_cap; Genode::Signal_context_capability _data_cap;
bool _stopped; /* state */
bool _progress_sigh; /* progress signal on/off */ bool _progress_sigh; /* progress signal on/off */
bool _alloc_sigh; /* alloc signal on/off */ bool _alloc_sigh; /* alloc signal on/off */
public: public:
Session_rpc_object(Genode::Signal_context_capability data_cap) Session_rpc_object(Genode::Env &env, Genode::Signal_context_capability data_cap)
: :
_stopped(true), _data_cap(data_cap), _ds(env.ram(), env.rm(), sizeof(Stream)),
_progress_sigh(false), _alloc_sigh(false) _data_cap(data_cap),
_stopped(true), _progress_sigh(false), _alloc_sigh(false)
{ {
_ds = Genode::env()->ram_session()->alloc(sizeof(Stream)); _stream = _ds.local_addr<Stream>();
_stream = static_cast<Stream *>(Genode::env()->rm_session()->attach(_ds));
}
virtual ~Session_rpc_object()
{
if (_ds.valid()) {
Genode::env()->rm_session()->detach(_stream);
Genode::env()->ram_session()->free(_ds);
}
} }
@ -84,7 +77,7 @@ class Audio_out::Session_rpc_object : public Genode::Rpc_object<Audio_out::Sessi
void start() { _stopped = false; } void start() { _stopped = false; }
void stop() { _stopped = true; } void stop() { _stopped = true; }
Genode::Dataspace_capability dataspace() { return _ds; } Genode::Dataspace_capability dataspace() { return _ds.cap(); }
/********************************** /**********************************

15
repos/os/src/drivers/audio/spec/linux/main.cc
View File

@ -55,9 +55,9 @@ class Audio_out::Session_component : public Audio_out::Session_rpc_object
public: public:
Session_component(Channel_number channel, Signal_context_capability data_cap) Session_component(Genode::Env &env, Channel_number channel, Signal_context_capability data_cap)
: :
Session_rpc_object(data_cap), Session_rpc_object(env, data_cap),
_channel(channel) _channel(channel)
{ {
Audio_out::channel_acquired[_channel] = this; Audio_out::channel_acquired[_channel] = this;
@ -239,6 +239,8 @@ class Audio_out::Root : public Audio_out::Root_component
{ {
private: private:
Genode::Env &_env;
Signal_context_capability _data_cap; Signal_context_capability _data_cap;
protected: protected:
@ -253,14 +255,14 @@ class Audio_out::Root : public Audio_out::Root_component
channel_number_from_string(channel_name, &channel_number); channel_number_from_string(channel_name, &channel_number);
return new (md_alloc()) return new (md_alloc())
Session_component(channel_number, _data_cap); Session_component(_env, channel_number, _data_cap);
} }
public: public:
Root(Genode::Entrypoint &ep, Allocator *md_alloc, Root(Genode::Env &env, Allocator &md_alloc,
Signal_context_capability data_cap) Signal_context_capability data_cap)
: Root_component(&ep.rpc_ep(), md_alloc), _data_cap(data_cap) : Root_component(env.ep(), md_alloc), _env(env), _data_cap(data_cap)
{ } { }
}; };
@ -293,8 +295,7 @@ struct Audio_out::Main
audio_drv_start(); audio_drv_start();
static Audio_out::Out out(env); static Audio_out::Out out(env);
static Audio_out::Root root(env.ep(), &heap, static Audio_out::Root root(env, heap, out.data_avail_sigh());
out.data_avail_sigh());
env.parent().announce(env.ep().manage(root)); env.parent().announce(env.ep().manage(root));
Genode::log("--- start Audio_out ALSA driver ---"); Genode::log("--- start Audio_out ALSA driver ---");
} }

23
repos/os/src/server/mixer/mixer.cc
View File

@ -124,8 +124,9 @@ struct Audio_out::Session_elem : Audio_out::Session_rpc_object,
float volume { 0.f }; float volume { 0.f };
bool muted { true }; bool muted { true };
Session_elem(char const *label, Genode::Signal_context_capability data_cap) Session_elem(Genode::Env & env,
: Session_rpc_object(data_cap), label(label) { } char const *label, Genode::Signal_context_capability data_cap)
: Session_rpc_object(env, data_cap), label(label) { }
Packet *get_packet(unsigned offset) { Packet *get_packet(unsigned offset) {
return stream()->get(stream()->pos() + offset); } return stream()->get(stream()->pos() + offset); }
@ -608,10 +609,11 @@ class Audio_out::Session_component : public Audio_out::Session_elem
public: public:
Session_component(char const *label, Session_component(Genode::Env &env,
char const *label,
Channel::Number number, Channel::Number number,
Mixer &mixer) Mixer &mixer)
: Session_elem(label, mixer.sig_cap()), _mixer(mixer) : Session_elem(env, label, mixer.sig_cap()), _mixer(mixer)
{ {
Session_elem::number = number; Session_elem::number = number;
_mixer.add_session(Session_elem::number, *this); _mixer.add_session(Session_elem::number, *this);
@ -647,8 +649,9 @@ class Audio_out::Root : public Audio_out::Root_component
{ {
private: private:
Mixer &_mixer; Genode::Env &_env;
int _sessions = { 0 }; Mixer &_mixer;
int _sessions = { 0 };
Session_component *_create_session(const char *args) Session_component *_create_session(const char *args)
{ {
@ -681,7 +684,7 @@ class Audio_out::Root : public Audio_out::Root_component
throw Root::Invalid_args(); throw Root::Invalid_args();
Session_component *session = new (md_alloc()) Session_component *session = new (md_alloc())
Session_component(label, (Channel::Number)ch, _mixer); Session_component(_env, label, (Channel::Number)ch, _mixer);
if (++_sessions == 1) _mixer.start(); if (++_sessions == 1) _mixer.start();
return session; return session;
@ -696,10 +699,10 @@ class Audio_out::Root : public Audio_out::Root_component
public: public:
Root(Genode::Entrypoint &ep, Root(Genode::Env &env,
Mixer &mixer, Mixer &mixer,
Genode::Allocator &md_alloc) Genode::Allocator &md_alloc)
: Root_component(&ep.rpc_ep(), &md_alloc), _mixer(mixer) { } : Root_component(env.ep(), md_alloc), _env(env), _mixer(mixer) { }
}; };
@ -716,7 +719,7 @@ struct Mixer::Main
Genode::Sliced_heap heap { env.ram(), env.rm() }; Genode::Sliced_heap heap { env.ram(), env.rm() };
Audio_out::Mixer mixer = { env }; Audio_out::Mixer mixer = { env };
Audio_out::Root root = { env.ep(), mixer, heap }; Audio_out::Root root = { env, mixer, heap };
Main(Genode::Env &env) : env(env) Main(Genode::Env &env) : env(env)
{ {

4
repos/ports/src/virtualbox/audiodrv.cpp
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2015 Genode Labs GmbH * Copyright (C) 2015-2017 Genode Labs GmbH
* *
* This file is distributed under the terms of the GNU General Public License * This file is distributed under the terms of the GNU General Public License
* version 2. * version 2.
@ -341,7 +341,7 @@ static int genode_init_in(HWVoiceIn *hw, audsettings_t *as)
GenodeVoiceIn *in = (GenodeVoiceIn*)hw; GenodeVoiceIn *in = (GenodeVoiceIn*)hw;
try { try {
in->audio = new (vmm_heap()) Audio_in::Connection("left"); in->audio = new (vmm_heap()) Audio_in::Connection(genode_env(), "left");
} catch (...) { } catch (...) {
Genode::error("could not establish Audio_in connection"); Genode::error("could not establish Audio_in connection");
return -1; return -1;