Audio n-Genie: Domain Specific Language for Audio Processing

Audio Engineering Society

Convention Paper Presented at the 126th Convention 2009 May 7–10 Munich, Germany The papers at this Convention have been selected on the basis of a submitted abstract and extended precis that have been peer reviewed by at least two qualified anonymous reviewers. This convention paper has been reproduced from the author's advance manuscript, without editing, corrections, or consideration by the Review Board. The AES takes no responsibility for the contents. Additional papers may be obtained by sending request and remittance to Audio Engineering Society, 60 East 42nd Street, New York, New York 10165-2520, USA; also see www.aes.org. All rights reserved. Reproduction of this paper, or any portion thereof, is not permitted without direct permission from the Journal of the Audio Engineering Society.

Audio n-Genie: Domain Specific Language for Audio Processing Tiziano Leidi1, Thierry Heeb2, Marco Colla3, and Jean-Philippe Thiran4 1

2

Research Scientist, ICIMSI – SUPSI, Galleria 2, CH-6928 Manno [email protected]

CEO, ANAGRAM Technologies SA, ZI Le Trési 6A, CH-1028 Préverenges [email protected] 3

Research Scientist, ICIMSI – SUPSI, Galleria 2, CH-6928 Manno [email protected] 4

Tenure-Track Assistant Professor, EPFL, CH-1015 Lausanne [email protected]

ABSTRACT Specialized development environments represent today an important added value for domain specific system providers suffering the lack of a dedicated, ergonomic, efficient and affordable tool able to boost their core business. This paper describes Audio n-Genie, a domain specific language and its associated development environment supporting the automatic production, by mean of component-based model-driven generative programming, of digital audio processing applications.

Leidi et al.

1.

Audio n-Genie interfaces and instrumentation to drive and test the application at run-time.

INTRODUCTION

Audio n-Genie combines a domain specific language and an associated development environment, into a tool featuring rapid prototyping, refinement and customization of digital audio processing applications. The result is made of a number of plug-ins for the open source development platform Eclipse [1]. These plugins, are based on the Eclipse infrastructure for domain specific languages, named Graphical Modeling Framework [2] and featuring functionality for visual modeling. Moreover, Audio n-Genie integrates with the Eclipse plug-in called C Development Tools [3] to support C and C++ development in the same environment. Audio n-Genie’s project started in 2003 around requirements for tools to speed-up development of embedded audio applications. The main goal was to reduce the impact of recurrent tasks in the software development process. By looking at code of some candidate audio applications, repetitive structures of the software architecture were identified to allow their automatic generation. At the heart of Audio n-Genie houses a specialized model engine that permits application designers to visually create, edit and navigate instances of an audio domain specific model. Audio n-Genie’s core infrastructure further provides automatic validation and different mechanisms for evolution and maintenance of model instance’s semantic contents. The user interface of Audio n-Genie is shown in figure 1. An editor is open in the middle of the user interface shown in the figure. Additional features of Audio n-Genie resides in source code generators. Driven by its core infrastructure, generators read model elements and subsequently produce source code implementations of the designed application. Generated applications may be used as prototypes or further refined into full featured audio processing applications. They are based on an efficient and extensible signal processing software architecture that also provides generated tailor-made graphical user

Audio n-Genie has been conceived by ICIMSI (Institute of Computer Integrated Manufacturing for Sustainable Innovation) in cooperation with ANAGRAM Technologies SA, a company with headquarters in Preverenges (Switzerland) active in the domain of consumer audio applications. In 2005, the first version of Audio n-Genie was presented to the public and new activities for its evolution started. During the same year some of its ground infrastructure was isolated into a core framework called System Designer that supports today 3 different application domains: audio signal processing, artificial vision and industrial automation. The main purpose of System Designer and tools like Audio n-Genie is to support domain specific modeling by mean of enabling techniques in the field of the automated production of applications. Domain specific applications are usually designed for a particular kind of activity and are sometimes required to work under strong constraints like: real-time operation, reduced memory size, low processing capacity, low power consumption, security awareness and optimal cost/quality ratio. Widely available generic development tools find some of their limits as soon as manageable variability needs to get aware of all possible implications. Domain specific tools featuring rapid prototyping and customization techniques represent therefore a valid alternative. The rest of this paper is organized as follows: chapter 2 introduces some sample applications used in subsequent chapters to describe Audio n-Genie. Chapter 3 explains some of the core concepts that are at the heart of Audio n-Genie. Chapter 4 deals with the internal structure of the tool highlighting its major functionalities. Chapter 5 presents some of the advantages of using Audio nGenie for the development of audio processing applications. Details about the source code produced by Audio n-Genie’s generators are available in chapter 6, while chapter 7 evaluates the results of some experiments done by using it. Finally chapter 8 introduces related work and presents an outlook of possible future evolutions. Chapters 9 and 10 provide conclusions and acknowledgments.

AES 126th Convention, Munich, Germany, 2009 May 7–10 Page 2 of 11

Leidi et al.

Audio n-Genie

Figure 1 – User interface of Audio n-Genie

2.

SAMPLE APPLICATIONS

With the goal to introduce some of the most prominent functionalities and structural traits of Audio n-Genie, together with some details of the source code produced by its generators, two sample audio processing applications will be used in this paper. They have been designed with the tool and generated to obtain prototype versions of them. The first one is called TestFilter and is a two-band parametric equalizer taking advantage of a module called pareq. This latter is part of CSound [4] and implements a classic algorithm for IIR audio filtering [5]. An experimental integration of CSound into Audio n-Genie has been recently performed and some of the modules are therefore available as components for application design. The generated user interface of the prototype for the TestFilter application is shown in figure 2.

The second sample application is called DSP_HP and has been ported to Audio n-Genie from a manually implemented Winamp plug-in, sharing the same functionality, but built on top of the Winamp SDK. DSP_HP is an application composed of several modules featuring well-known techniques (more details in following paragraphs) for enhancing the audio experience when listening over headphones. Various parameters are exported from the plugin and can be changed at real-time. The version generated by Audio n-Genie of DSP_HP is a stand-alone application featuring functionality to read audio files, process them and output the result over the PC's embedded sound card or on a file. The generated graphical user interface allows real-time modification of parameters too. Performance comparison of both applications will be discussed in chapter 7. DSP_HP has four main modules:

AES 126th Convention, Munich, Germany, 2009 May 7–10 Page 3 of 11

Leidi et al.

Audio n-Genie

• Headphone: This module uses different publicly available databases of Head Related Transfer Functions (HRTF) to simulate different panning of the left and right channels of a stereo audio stream (from fully in front of the listener to virtual audio sources slightly behind the listener). The HRTF filtering is implemented by the means of time domain convolution. Some widening effect can also be added if desired by the user.

prolonged listening sessions. In order to reduce this unpleasant perception, the Room module implements acoustical simulation of a listening room. The human perception of its auditory environment is heavily linked to the early reflections arrival times and amplitudes. Four early reflections bins and a global feedback with user programmable delays and gains provide a low complexity simulation of room acoustics, making the brain believe it listens to audio in an actual room and not over headphones.

• Harmonize: In this module a slight amount of harmonics (mostly second order) is added to the signal in the upper part of the spectrum. The user can set the overall gain of the harmonics generation process. This process is implemented by FIR linear phase filtering coupled with squaring and DC removal. This is similar to rectification, a technique commonly used for generation of harmonics, but with the additional benefit of a smoother output waveform. • Bass: Due to the limited low frequency bandwidth of most low cost headphones, a user programmable boost of low-frequency content is integrated into DSP_HP. It is implemented as a gain programmable low frequency shelving filter, implemented by a second order IIR. • Room: One of the most annoying artifacts of headphone listening is the sensation that music actually plays inside of the head of the listener. Although one may not notice this phenomenon for short term listening, it gets really annoying for

Figure 2 – GUI of the TestFilter application Figure 3 shows all modules of the DSP_HP application together with two additional modules: the file reader, and the sound card player.

Figure 3 – Screenshot of modules of the DSP_HP application

AES 126th Convention, Munich, Germany, 2009 May 7–10 Page 4 of 11

Leidi et al.

3.

Audio n-Genie

CORE CONCEPTS

To provide software prototyping and customization of applications, Audio n-Genie takes advantage of some well known and assessed development techniques: • Component-based development: different preexisting parts of code are treated as black boxes and joint together to compose software applications. In order to be components, code snippets coming from different sources have to exhibit independently deployable functionality [6, 7, 8, 9, 19]. • Pattern-based development: a design pattern is a structural characteristic of software that may be replicated to provide solutions for a recurring problem in software design. Patterns are normally combined to provide efficient and extensible software architectures. • Model-driven development: is a technique that focuses development around a high-level, abstract, often iterative data structure. Models are created during early phases of tool conception and provide specifications for successive phases and for software parts that exploit them. Models evolve as tool design and implementation takes place [10, 11, 18]. • Generative programming: is a software development approach focused on the exploitation of automatic processes for the production of source code’s replicable parts [12, 13, 14, 15, 16, 17, 18]. • Aspect-oriented software development: is a programming paradigm converging towards separation of concerns during software design and implementation. Aspects normally are specific crosscutting concerns that impact the structure of source code in a way that is not localized to a single component [18] [19]. 4.

STRUCTURE OF THE TOOL

In Audio n-Genie, the development techniques presented in the previous chapter have been combined into a domain specific language (DSL) provided as a complete development tool. This has been done by complementing the flexibility of the DSL with ergonomic graphical user interfaces and functionalities thoughts to make its adoption easier. Coverage of the

whole development process from application design and prototyping, to its finalization and optimization is therefore provided in an integrated, automated environment. In order to understand the structure of Audio n-Genie, it is important to highlight that it is composed of: • An abstraction, the model: defines all common characteristics of the application family with possibilities in which a single member of the family (an audio application) may differ from another. The model defines type of elements, related rules and constraints used to compose such elements. • Visual editors: allow designers to instantiate, access and modify model elements. Editors further provide specialized features to speed-up design phases. The validation engine integrated with editors is responsible to check model constraints and provide feedback to the user in form of errors and warnings. • Code generators: traverse the information contained in model instances and transform it in source code (C, C++, assembly, etc.). Generated code reflects the structure of the designed audio application and provides features that enhance performances and stability, together with additional mechanisms for simulation, debugging and configuration of functionalities. Model driven development has therefore been used to collect important properties of the application family designable using Audio n-Genie’s DSL. These characteristics, combined in the model, are all abstract traits of components, patterns and aspects that are then reflected in the source code produced by generators. Generative programming has then been exploited to provide automatic transformations from model instances to concrete code implementations. Source code is produced for components, for glue code used to combine them, for graphical user interfaces and for all additional and by chance orthogonal functionalities needed in the final executable. Design patterns and Aspect oriented techniques have instead been exploited in generators to structure the producible source code, consequently furnishing an efficient and flexible architecture. Audio n-Genie’s graphical user interface and all its assisting functionalities take advantage of model driven

AES 126th Convention, Munich, Germany, 2009 May 7–10 Page 5 of 11

Leidi et al.

Audio n-Genie

development too. As the central repository of information, they operate on the model in a direct way. The synergic combination of model, user interface and assisting functionalities represents therefore a clean, specialized, visual environment where application may be designed by concentrating on their fundamental and domain specific peculiarities.

• Growth and review of the design may be performed directly at model level where automatic model-tomodel transformations are of further advantage. The generator will then automatically reflect all changes in sources.

GUI Assisting Functionalities

Model

Model validation Model refactoring Model transformations

Components abstraction Patterns abstraction Aspects abstraction

Source Code Generators Generated Applications

Components - Patterns - Aspects

Figure 4 – Structure of the development environment On the other side, integration with the CDT plug-in for Eclipse provides editing, compilation and debugging functionalities for C, C++ and assembly, permitting to test, configure and customize generated sources. For particular parts of the code it is also possible to work in a round-trip fashion through mechanisms able to reflect source code modifications in the model. This tight cooperation between modeling functionalities and traditional source code development tools permits model and generators to be a complement of the classic development techniques instead of a substitute. 5.

• Design phases may follow a rather agile approach by taking advantage of model’s flexibility and essentiality. Compared to development phases at source code level, design phases at model level may be shorter and may therefore be iterated frequently. Evolutionary development is thus strongly favored.

DEVELOPMENT ADVANTAGES

Compared to traditional application development this kind of approach furnishes some important advantages: • First of all, code reuse of components is favored by their black-box structure and their standardized way to communicate with encapsulated implementations. It is important to note that components may be implemented from scratch, or integrated from preexisting libraries or frameworks, thus allowing reuse of preexisting IP and combination of multisourced IP.

• Source code may contain structures that could be difficult or error prone to write and maintain by hand. Generators are able to perform relatively complex transformations that may further be of advantage to grant application performances and robustness (more details about this benefit will be given in next chapter). • Generated code, compared to hand-written code, will be cleaner and will contain only needful functionalities. By disabling unnecessary features in the model, it is indeed possible to obtain compact applications, both from the point of view of features that are provided and from the point of view of the executable size. Further provided advantages are related to Audio nGenie’s support for rapid prototyping. In the software development industry, this development paradigm is used to quickly produce incomplete working versions of the application by assembling and modifying available software components. Prototypes allow validating various traits of the application design and may be used as demo version to show ideas and to gather feedback from stakeholders. Rapid prototyping is normally used in combination with evolutionary development processes as a way to reduce development risk and costs. These advantages obviously have a counterpart. The through potential of generative programming is its ability to reduce all the available development variability by constraining the producible application family to a well known and tested set. The family of applications that may be obtained by mean of generators is consequently substantially smaller than the whole family of applications producible in hand-written code. It is however important to state that lots of

AES 126th Convention, Munich, Germany, 2009 May 7–10 Page 6 of 11

Leidi et al.

Audio n-Genie

applications of this second larger family, may exhibit structural problems, poor performances, bugs. Generators help filtering them out.

unit for different execution phases of the whole application. These phases are snippets of code that carry out audio algorithms and that are associated with units. Furthermore, in Audio n-Genie, the concept behind the pipeline pattern has been enhanced to support networks of connection instead of just chains of them. The resulting combination of communication paths between units is called configuration and freedom to build cyclic graphs has been left to the user for feedback loops that are often required in the audio application domain. As an example, Figure 6 shows the configuration of the TestFilter application.

Figure 5 – Unit of the pareq filter 6.

DETAILS OF THE GENERATED CODE

In order to understand the functionality provided by Audio n-Genie’s source code generators and in order to highlight its specialization to the audio application domain, some of the details of the generated software architecture are given in this chapter with corresponding support in the model.

Buffering provided between components is an important feature of the pipelines and filters pattern. Applied to signal processing it is of particular benefit for performance optimization. Instead of processing a single sample in each unit, before switching to the successive units, it is possible to process and buffer a block of them. The resulting code will take advantage of the principle of locality [21], thus dramatically reducing the cost of context switches between units.

One of the fundamental patterns, used in the software architecture, is the classic and simple pipes and filters pattern. A pipeline is obtained by combining processing components by chaining their inputs and outputs with connections. Between consecutive components, buffers are used to let data flow. Processing components of the pipeline are in Audio nGenie black-box modules called units. Figure 5 shows the unit of the pareq filter used in the TestFilter application described in chapter 2. The pipes and filters pattern has been complemented in Audio n-Genie with a derivate of the strategy pattern [20]. This allows freely specifying the behavior of the

Figure 6 – Screenshot of the configuration of the TestFilter

AES 126th Convention, Munich, Germany, 2009 May 7–10 Page 7 of 11

Leidi et al.

Audio n-Genie

Aspect oriented techniques are very useful to manage code optimizations. This makes particularly sense when changes impact the architecture in an orthogonal way by modifying spread out parts. Available tools for aspect oriented programming (e.g. AspectJ [22]) provide a solution to the aspect problem by extending an existing programming language (e.g. Java) with specialized instructions made to specify cross cutting concerns. An enhanced compiler is then responsible to do the job of distributing changes. In Audio n-Genie a different approach has been exploited: the information concerning aspects is specified in the model in a unique centralized location. It is then distributed by generators to all places of the source code requiring it. As previously stated, generators are able to perform rather complex transformations between abstract information contained in model and related sources. They are therefore very well suited for the distribution of cross cutting concerns in multiple source code locations. The aspect that is responsible for the buffering optimization in Audio n-Genie is called block processing aspect and its information may be independently specified for each configuration. Contained information relates to the availability or absence of blocks (in some situations they are meaningless) and to their size. The software architecture may therefore be adapted to tune application performances. Unit3

Unit1

Unit2

Unit3

Block

Unit2

No Block

Unit1

Figure 7 – Block Processing There’s another detail related to the block processing aspect that has to be described: in Audio n-Genie, two different streams of connections are possible between units. Their names are parameter links (in green in figure 5) and data links (in blue in figure 5). While the formers are thought to support communication of control information, the latter are specific for audio samples.

The transformation performed by the generator is different for these two kinds of communication’s streams. Even if block processing is active, buffers are never used for parameter and therefore their communication rate is significantly lower (a block size fraction) compared to the rate used for communicating audio data. Parameter links are therefore handled with lower priority, practically considering just their instantaneous value, compared to data links that are instead considered first citizens in Audio n-Genie. This mechanism is again of huge advantage when tuning performances. Similar approaches to the buffer enhancement automated by Audio n-Genie has been discovered in the software architecture of audio signal processing applications like CSound [4], where they have been implemented through handwritten code. Another important pattern, that has been exploited in Audio n-Genie and which is worth of mention, is the composite pattern [20]. Its behavior is easily clarified: through composition a configuration may be encapsulated in a new unit that may thus be used inside another configuration. Flexibility has hence been added in form of chances to build recursive structures and to reuse preexisting designs. All processing modules of the DSP_HP application described in chapter 2 are composites. Figure 8 shows the internal configuration of one of them: the harmonize module. To design a composite the configuration to encapsulate has to be visually enclosed in its own black-box and used in the containing configuration as if it were a normal unit. Generators are then able to produce code that treats the configuration as a component with independent deployable functionality. Design reuse is therefore transformed into effective source code reuse. Composites raise the design flexibility of Audio nGenie in a further particular way. By taking advantage of a specialized assisting feature it is possible to morph a unit into composite or the other way around. Topdown design and development is hence possible instead of the more tradition bottom-up approach. This allows for a complete “V” cycle type of development.

AES 126th Convention, Munich, Germany, 2009 May 7–10 Page 8 of 11

Leidi et al.

Audio n-Genie

Figure 8 – Screenshot of the composite of the harmonize module

Designers may in fact visually specify exposed parameters and data connectors of a unit and connect them with other units inside a configuration. There’s no need to promptly specify their internal behavior. It is possible to add it afterwards by morphing between unit and composite in order to specify if it’s an implementation done with algorithms or by composition of another configuration. 7.

EXPERIMENTAL EVALUATION

Both sample applications described in chapter 2 were useful to validate Audio n-Genie’s approach, at least at an experimental level, from different points of view. The TestFilter application demonstrated that integration and reuse of preexisting code into Audio n-Genie is possible, therefore favoring rapid prototyping of applications. Up to 300 CSounds components have been integrated into Audio n-Genie without loss of processing efficiency. They now furnish ready to use classic audio processing and sound synthesis algorithms. By exploiting them, the prototype of the TestFilter application has been designed, produced and optimized in less then half an hour. Such a prototype is complete from the point of view of the functionality. Some details of the graphical user interface could however be finalized to provide more ergonomic behavior to the end-user. The DSP_HP sample application represents instead a more important experimental evaluation. First of all a

comparison between a handwritten application and its equivalent in generated code has been performed. Even if they differ in some of their structural details, an important amount of consequent considerations are possible. First of all, using the same hardware platform to test them, the WinAmp version of DSP_HP reported consumption between 26% and 31% of the available CPU resources. Audio n-Genie’s generated version was instead able to execute in a range between 24% and 27%. Furthermore, global processing latency is substantially smaller using the generated version. These improvements were possible by fine tuning buffer sizes (buffers of 32 samples were used without excessively compromising the CPU consumption). These results highlight that the systematic production and optimization of source code through generators may be of advantage when dealing with constraints and performances. Please note that Audio n-Genie’s version is still a prototype and some important optimization opportunities are still available, particularly at an algorithmic level. From the point of view of the porting effort, the time spent to achieve a ready to use application was significantly shorter when using Audio n-Genie. All the scaffolding code and the graphical user interface were generated in less then a minute and without bugs directly from the design of the application. Such a result demonstrated most of the advantages of the rapid prototyping approach through model-driven generative programming. While porting the application we further discovered and fixed some functional imperfections and

AES 126th Convention, Munich, Germany, 2009 May 7–10 Page 9 of 11

Leidi et al.

Audio n-Genie

bugs that were present in the handwritten WinAmp version. By using DSLs and generative programming, application designer are allowed to concentrate just on functional features therefore easily improving the robustness of the application. During the design of the DSP_HP application an important amount of Audio n-Genie’s features were used. These are e.g. composites and the flexible buffers optimization provided by the block processing aspect. The DSP_HP is therefore an important testimonial of Audio n-Genie’s capabilities. 8.

RELATED WORK AND OUTLOOK

While a direct comparison is meaningless, it is possible to state that Audio n-Genie is a tool sharing some similarities with generic development tools (e.g. Microsoft Visual Studio) or with simulation environments and hardware control tools like Matworks Matlab/Simulink [23] and National Instruments Labview. Audio n-Genie is obviously of smaller size, but it is highly specialized and conceived to fulfill the needs of the audio-specialized software engineer. It has to be functionally positioned in the middle of these two categories of development environments. Like generic development tools it provides features for source code development. Through the DSL and generators, developers are however able to speed-up software design and implementation by automating the production and optimization of audio processing code On the other side, like simulation environment and hardware control tools, it provides an abstract visual model and code generators. The source code generated by Audio n-Genie is anyway structured as an advanced customizable framework and functionalities to extend it are provided in the same development environment. It acts therefore as a complement to generic programming languages like C and C++ instead of being a substitution. There are more features available in Audio n-Genie. Like those described in this paper, they have been implemented through patterns and aspects in the generated software architecture and have been supported by model-driven generative programming in the DSL. All features illustrated in this paper are relatively simple from the conceptual point of view, but are wonderful candidates to show how rapid prototyping and customization techniques may be exploited in the specific domain of audio applications.

An important amount of problems that may be addressed by using the described approach, have been investigated and evolutions of Audio n-Genie are currently under development. As an example the current beta version of Audio n-Genie support the design of applications able to exploit parallel processing on symmetric multi processors and multi-cores. Furthermore, the code generated by Audio n-Genie has been ported to various hardware platforms and operating systems: embedded computers, DSPs, SoCs and PCs (Win, Linux, OSX). The generation of applications for simulation is a further specialization of Audio n-Genie (particularly in combination with SoCs emulators). 9.

CONCLUSIONS

This paper introduced Audio n-Genie: a software development tool supporting domain specific modeling, rapid prototyping and customization of applications by mean of techniques in the field of the automated production of applications. These are: component-based development, pattern-based development, model-driven development, aspect oriented and generative programming. While they are not a panacea to all potential development difficulties, these techniques are able to be of advantage e.g. to reduce development time and favor application’s robustness. They consequently help constraining development costs and risks. Audio n-Genie is today available under the EPL open source license. It is used as a development platform for the simulation and production of audio applications and as an experimental environment for academic research activities. More information is available at: www.systemdesigner.ch www.anagramtech.com/audio-n-genie/. 10.

ACKNOWLEDGEMENTS

We would like to thank CTI (the Swiss Confederation’s promotion agency) and Anagram Technologies SA for providing the required funds and resources to develop Audio n-Genie. Furthermore we would like to thank all the researchers and engineers that contributed to it.

innovation

AES 126th Convention, Munich, Germany, 2009 May 7–10 Page 10 of 11

Leidi et al. 11.

Audio n-Genie conference on Generative Programming Component Engineering, 2002.

REFERENCES

[1] http://www.eclipse.org

and

[14] X. Ke, K. Sierszecki. Generative Programming for a Component-based Framework of Distributed Embedded Systems. 6th OOPSLA Workshop on Domain-Specific Modeling, 2006.

[2] http://www.eclipse.org/modeling/gmf/ [3] http://www.eclipse.org/cdt/

[15] M. Jung. Synthesizing Program Generators for Embedded Software. Shaker Verlag, 2007.

[4] http://www.csounds.com [5] Udo Zölzer. Digital Audio Signal Processing. Wiley. [6] T.L. Veldhuizen. Parsimony Principles for Software Components and Metalanguages. International Conference on Generative Programming and Component Engineering, 2007. [7] Padmal Vitharana. Risks and challenges of component-based software development. Communications of the ACM, August 2003. [8] J. Hiipakka. A Component-Based Software Architecture for Realtime Audio Processing Systems. International Conference on Signal Processing and Multimedia Applications, 2006. [9] Clemens Szyperski. Component Software: Beyond Object Oriented Programming. Addison-Wesley, 2002. [10] J-M. Favre. Towards a Basic Theory to Model Driven Engineering. Workshop on Software Model Engineering, 2004. [11] T. Stahl, M. Voelter, K. Czarnecki. Model-Driven Software Development: Technology, Engineering, Management. Wiley, 2006. [12] J. Litsios. Generative and Transformational Techniques in Software Engineering. Dr. Dobb's Journal, 2006. [13] J. Sztipanovits, G. Karsai. Generative Programming for Embedded Systems. 1st

[16] Krzysztof Czarnecki and Ulrich W. Eisenecker, Generative Programming – Methods, Tools and Applications. Addison-Wesley, 2000. [17] S. Trujillo, M. Azanza. O. Diaz, Generative Metaprogramming. International Conference on Generative Programming and Component Engineering, 2007. [18] M. Voelter, I. Groher. Product Line Implementation using Aspect-Oriented and Model-Driven Software Development. 11th International Software Product Line Conference, 2007. [19] F. Cao, B.R. Bryant, C.C. Burt, R.R. Raje, A.M. Olson, M. Auguston. A Component Assembly Approach Based On Aspect-Oriented Generative Domain Modeling. Proceedings of the Software Composition Workshop, 2004. [20] Erich Gamma, Richard Helm, Ralph E. Johnson and John Vlissides. Design Patterns. Elements of Reusable Object-Oriented Software. AddisonWesley, 1995. [21] Peter J.Denning. The Locality Principle. ACM, 2005. [22] http://www.eclipse.org/aspectj/ [23] Arvind Ananthan. Rapid-prototyping and Implementing Audio Algorithms on DSPs using Model Based Design and Automatic Code Generation. 123rd Convention AES Convention.

AES 126th Convention, Munich, Germany, 2009 May 7–10 Page 11 of 11