static void upipe_dump_input(struct upipe *upipe, struct uref *uref,
struct upump **upump_p)
{
struct upipe_dump *upipe_dump = upipe_dump_from_upipe(upipe);
uref_dump(uref, upipe->uprobe);
size_t total_size;
ubase_assert(uref_block_size(uref, &total_size));
upipe_notice_va(upipe, "dumping ubuf %p of size %zu",
uref->ubuf, total_size);
if (upipe_dump->max_len != (size_t)-1 &&
total_size > upipe_dump->max_len)
total_size = upipe_dump->max_len;
unsigned int count = 0;
uint8_t line[16];
int offset = 0;
while (total_size) {
const uint8_t *buf;
int size = total_size;
ubase_assert(uref_block_read(uref, offset, &size, &buf));
assert(size != 0);
total_size -= size;
for (unsigned i = 0; i < size; i++, count++) {
line[count % 16] = buf[i];
if (!((count + 1) % 16) || (!total_size && (i + 1 == size)))
upipe_dump_line(upipe, count - (count % 16),
line, (count % 16) + 1);
}
ubase_assert(uref_block_unmap(uref, offset));
offset += size;
}
#define UPIPE_DUMP_SEP \
"--------------------------------------------" \
"-------------------------------------------"
upipe_notice(upipe, UPIPE_DUMP_SEP);
upipe_dump_output(upipe, uref, upump_p);
}
/** @internal @This checks the presence of the sync word.
*
* @param upipe description structure of the pipe
* @param uref uref structure
* @param upump_p reference to pump that generated the buffer
*/
static bool upipe_ts_check_check(struct upipe *upipe, struct uref *uref,
struct upump **upump_p)
{
const uint8_t *buffer;
int size = 1;
uint8_t word;
if (unlikely(!ubase_check(uref_block_read(uref, 0, &size, &buffer)))) {
uref_free(uref);
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return false;
}
assert(size == 1);
word = *buffer;
uref_block_unmap(uref, 0);
if (word != TS_SYNC) {
uref_free(uref);
upipe_warn_va(upipe, "invalid TS sync 0x%"PRIx8, word);
return false;
}
upipe_ts_check_output(upipe, uref, upump_p);
return true;
}
/** @internal @This converts block urefs to sound urefs.
*
* @param upipe description structure of the pipe
* @param uref uref structure
* @param upump_p reference to pump that generated the buffer
*/
static void upipe_block_to_sound_input(struct upipe *upipe, struct uref *uref, struct upump **upump_p)
{
struct upipe_block_to_sound *upipe_block_to_sound = upipe_block_to_sound_from_upipe(upipe);
/* get block size */
size_t block_size = 0;
uref_block_size(uref, &block_size);
/* drop incomplete samples */
if ((block_size % upipe_block_to_sound->sample_size) != 0) {
upipe_warn(upipe, "Incomplete samples detected");
}
int samples = block_size / upipe_block_to_sound->sample_size;
block_size = samples * upipe_block_to_sound->sample_size;
/* alloc sound ubuf */
struct ubuf *ubuf_block_to_sound = ubuf_sound_alloc(upipe_block_to_sound->ubuf_mgr,
samples);
if (unlikely(ubuf_block_to_sound == NULL)) {
uref_free(uref);
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return;
}
/* map sound ubuf for writing */
int32_t *w;
if (unlikely(!ubase_check(ubuf_sound_write_int32_t(ubuf_block_to_sound, 0, -1, &w,
upipe_block_to_sound->planes)))) {
upipe_err(upipe, "could not write uref, dropping samples");
ubuf_sound_unmap(ubuf_block_to_sound, 0, -1, upipe_block_to_sound->planes);
ubuf_free(ubuf_block_to_sound);
uref_free(uref);
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return;
}
/* map block ubuf for reading */
const uint8_t *r;
int end = -1;
if (unlikely(!ubase_check(uref_block_read(uref, 0, &end, &r)))) {
upipe_err(upipe, "could not read uref, dropping samples");
ubuf_sound_unmap(ubuf_block_to_sound, 0, -1, upipe_block_to_sound->planes);
ubuf_block_unmap(uref->ubuf, 0);
ubuf_free(ubuf_block_to_sound);
uref_free(uref);
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return;
}
/* copy block to sound */
memcpy(w, r, block_size);
/* unmap ubufs */
ubuf_sound_unmap(ubuf_block_to_sound, 0, -1, upipe_block_to_sound->planes);
ubuf_block_unmap(uref->ubuf, 0);
/* attach sound ubuf to uref */
uref_attach_ubuf(uref, ubuf_block_to_sound);
/* output pipe */
upipe_block_to_sound_output(upipe, uref, upump_p);
}
/** @internal @This handles data.
*
* @param upipe description structure of the pipe
* @param uref uref structure
* @param upump_p reference to pump that generated the buffer
*/
static bool upipe_s337_encaps_handle(struct upipe *upipe, struct uref *uref,
struct upump **upump_p)
{
struct upipe_s337_encaps *upipe_s337_encaps = upipe_s337_encaps_from_upipe(upipe);
if (!upipe_s337_encaps->ubuf_mgr)
return false;
size_t block_size;
if (!ubase_check(uref_block_size(uref, &block_size))) {
upipe_err(upipe, "Couldn't read block size");
uref_free(uref);
return true;
}
struct ubuf *ubuf = ubuf_sound_alloc(upipe_s337_encaps->ubuf_mgr, A52_FRAME_SAMPLES);
if (!ubuf)
return false;
if (block_size / 2 > A52_FRAME_SAMPLES - 4) {
upipe_err_va(upipe, "AC-3 block size %zu too big", block_size);
block_size = (A52_FRAME_SAMPLES - 4) * 2;
}
int32_t *out_data;
ubuf_sound_write_int32_t(ubuf, 0, -1, &out_data, 1);
/* Pa, Pb, Pc, Pd */
out_data[0] = (S337_PREAMBLE_A1 << 24) | (S337_PREAMBLE_A2 << 16);
out_data[1] = (S337_PREAMBLE_B1 << 24) | (S337_PREAMBLE_B2 << 16);
out_data[2] = (S337_TYPE_A52 << 16) | (S337_MODE_16 << 21) |
(S337_TYPE_A52_REP_RATE_FLAG << 24);
out_data[3] = ((block_size * 8) & 0xffff) << 16;
int offset = 0;
uint8_t tmp = 0;
while (block_size) {
const uint8_t *buf;
int size = block_size;
if (!ubase_check(uref_block_read(uref, offset, &size, &buf)) || size == 0) {
ubuf_sound_unmap(ubuf, 0, -1, 1);
ubuf_free(ubuf);
uref_free(uref);
return true;
}
if (offset & 1) {
out_data[4 + offset/2] = (tmp << 24) | (buf[0] << 16);
buf++;
offset++;
block_size--;
size--;
}
for (int i = 0; i < size/2; i++)
out_data[4 + offset/2 + i] = (buf[2*i + 0] << 24) | (buf[2*i + 1] << 16);
if (size & 1)
tmp = buf[size-1];
uref_block_unmap(uref, offset);
block_size -= size;
offset += size;
}
memset(&out_data[4 + offset/2], 0, 4 * (A52_FRAME_SAMPLES*2 - 4 - offset/2));
ubuf_sound_unmap(ubuf, 0, -1, 1);
uref_attach_ubuf(uref, ubuf);
upipe_s337_encaps_output(upipe, uref, upump_p);
return true;
}
