This test group is intended to check the format / codec transcoding
capabilities of the library. The reference files are used to ensure
that encoding or decoding was successful.
The following formats are currently being tested:
- amr_efr
- gsm
- racal_hr
- racal_fr
- racal_efr
- ti_hr
- ti_fr
- ti_efr
- rtp_efr
- rtp_hr_etsi
- rtp_hr_ietf
This test is intended to check the RTP source / sink operability.
To do this, two processing queues are being allocated:
"generator": source/random -> sink/rtp
"checker": source/rtp -> sink/checker
The first one generates some amount of random bytes (payload),
and stores them inside a buffer that is shared between both
queues.
After generation, a payload is being sent from the first
queue via an RTP sink, and then being received by the second
via an RTP source.
As both queues do use a shared buffer, the last item of the
second queue (named 'sink/checker') is able to compare a
received payload with expected.
This test is intended to check the file source / sink
operability. To do that, the following processing chain
is being composed:
source/file -> proc/dummy -> sink/file (stdout)
The source item opens the sample file named 'io_sample.txt'
for reading. The next processing item simply converts all
uppercase latters to the lowercase. The last one writes
the result to stdout.
This processing cycle is being repeated several times
with different block length values.
This test is intended to validate the processing queue
management API. Moreover, the talloc debugging API is
used to ensure that there are no memory leaks.
First, four processing queues are being allocated. One
of them is empty, while others have different count of
items. Then the human-readable description is being
generated for all of them. And finally, the processing
and exit cllback are being tested.
During the test execution, the talloc NULL-context
tracking feature is enabled, allowing to observe every
memory allocation within the libosmogapk, and to detect
memory leaks.
The talloc_size() call sets the current file name and the current
line number as name for chunk being allocated. This combination
is not so informative during debugging, so let's use the static
'.buffer' string as context name for item's output buffer.
In order to give advanced control over a processing queue,
it would be better to have the checking function separated from
the osmo_gapk_pq_prepare(). Moreover, this change introduces an
additional 'strict' checking mode that requires a queue to have
a source item first and a sink item in the last position.
This change adds two meta-information fields to the processing
queue item structure. Both of them will be used for more
detailed logging and for the human-readable processing
queue description.
There are currently three types of prcessing queue items:
- source (file, alsa, rtp)
- proc (format, codec)
- sink (file, alsa, rtp)
Let's assign corresponding type for each item.
This would facilitate logging and the queue checking.
Since this change, every processing queue may optionally have
an associated human-readable name. If name is not required,
NULL should be passed to the osmo_gapk_pq_create().
In order to simplify memory leak debugging, this change introduces
the library's internal talloc context that may be changed by
external application by calling the osmo_gapk_set_talloc_ctx().
There are not so much code, related to internal logging subsystem.
So, there is no reason to keep a few lines in a dedicated file.
In the future one may also be used for other routines.
Previously the osmo-gapk application used to exit as soon as all
the frames are processed, no matter has the sink finished its
internal processing (e.g. ALSA playback).
In some cases it's required to wait for some queue items
to finish processing. For example, the ALSA sink writes the
audio samples to the buffer in non-blocking mode, so as soon
as all of them will be written, a program may finish execution,
causing the playback abort.
To prevent that, this change extends the library's API, allowing
each queue item to have a processing state callback that returns
a positive integer if processing is not finished yet,
and 0 otherwise.
Instead of immediately shutting down the application, it is
better to try to break the processing queue first, and stop
the execution immediately if second SIGINT is received.
The printf() writes the text into stdout, which may be undesirable
in some use cases. Moreover, the printed information was redundant.
So, let's drop such calls.
Since this change, the libosmogapk uses the Osmocom logging
framework. By default, logging is disabled and could be enabled
by the external applications calling the osmo_gapk_log_init()
with a desired log target as an argument.
Since GAPK package contains a library and the representative
osmo-gapk application, the 'main.c' looks a bit confusing. Let's
use the common naming scheme.
The usage of linuxlist is more flexible than having a limited
array of pointers. This approach allows to have as much items
in a processing queue as required.
To simplify the benchrarking process via the library API, this
change introduces two new functions, which are intended to
provide total cycle and frame count.
Having statically allocated memory for benchmark data of every
codec causes high memory usage, especially if actual benchmarking
is not required for a particular use case. Instead of that, let's
provide an optional opportunity to enable benchmarking for a
particular codec by calling the osmo_gapk_bench_enable(). The
required amount of memory would be allocated, and then can be
freed by calling the osmo_gapk_bench_free() or manually.
The usage of a 'static inline' function definition in the 'bench.h'
is resulting in separate independent function definitions in each
translation unit from which the header is included. This is
increasing the size of compiled code unnecessarily.
There is no need to expose the implementation details of both
BENCHMARK_START and BENCHMARK_STOP macros via public header.
This change moves them to a separate private header 'bench.h'.
The benchmark_dump() is only used by the osmo-gapk binary, and
is intended to prepare and print benchmarking results to stderr,
what is most likely unusable for the library users.
To avoid a naming conflict between libosmogapk and other projects
during linkage, all the exposed symbols should have an unique
prefix. Let's use 'osmo_gapk' for that.
The most compilers today do support the '#pragma once', which is
designed to cause the current source file to be included only once
in a single compilation. One has several advantages, including:
less code, avoidance of name clashes, and sometimes improvement
in compilation speed.
See: https://en.wikipedia.org/wiki/Pragma_once for details.
To be able to use the library, external applications need to know,
which symbols are exposed. This information is provided by header
files, which are being installed to a system's ${includedir}
since this change.
The previous GAPK implementation was represented as a single
executable. So, all audio transcoding operations were available
only by calling the 'gapk' binary. This approach didn't allow
external applications to benefit from using GAPK API directly.
Since there are some projects (such as GR-GSM and OsmocomBB),
which are potential users of GAPK code base, it would be better
to have all transcoding functions within a shared library.
So, this change separates the common code into a shared library,
named 'libosmogapk', and links the 'gapk' binary against one.
Currently there are no shared headers, pkg-config manifest and
the export map, but they will be done latter.
Vadim Yanitskiy