/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_a52f_set_flow_def(struct upipe *upipe, struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
const char *def;
if (unlikely(!ubase_check(uref_flow_get_def(flow_def, &def)) ||
(ubase_ncmp(def, "block.ac3.") &&
ubase_ncmp(def, "block.eac3.") &&
strcmp(def, "block."))))
return UBASE_ERR_INVALID;
struct uref *flow_def_dup;
if (unlikely((flow_def_dup = uref_dup(flow_def)) == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return UBASE_ERR_ALLOC;
}
struct upipe_a52f *upipe_a52f = upipe_a52f_from_upipe(upipe);
upipe_a52f->input_latency = 0;
uref_clock_get_latency(flow_def, &upipe_a52f->input_latency);
if (unlikely(upipe_a52f->samplerate &&
!ubase_check(uref_clock_set_latency(flow_def_dup,
upipe_a52f->input_latency +
UCLOCK_FREQ * A52_FRAME_SAMPLES /
upipe_a52f->samplerate))))
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
flow_def = upipe_a52f_store_flow_def_input(upipe, flow_def_dup);
if (flow_def != NULL)
upipe_a52f_store_flow_def(upipe, flow_def);
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_agg_set_flow_def(struct upipe *upipe, struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
UBASE_RETURN(uref_flow_match_def(flow_def, EXPECTED_FLOW_DEF))
struct upipe_agg *upipe_agg = upipe_agg_from_upipe(upipe);
uint64_t size = 0;
uref_block_flow_get_size(flow_def, &size);
upipe_agg->input_size = size;
uint64_t octetrate = 0;
uref_block_flow_get_octetrate(flow_def, &octetrate);
uint64_t latency = 0;
uref_clock_get_latency(flow_def, &latency);
struct uref *flow_def_dup;
if ((flow_def_dup = uref_dup(flow_def)) == NULL)
return UBASE_ERR_ALLOC;
UBASE_RETURN(uref_block_flow_set_size(flow_def_dup, upipe_agg->output_size))
if (octetrate) {
UBASE_RETURN(uref_clock_set_latency(flow_def_dup, latency +
(uint64_t)upipe_agg->output_size * UCLOCK_FREQ / octetrate))
}
upipe_agg_store_flow_def(upipe, flow_def_dup);
return UBASE_ERR_NONE;
}
/** @internal @This merges the new access unit into a possibly existing
* incomplete PES, and outputs the PES if possible.
*
* @param upipe description structure of the pipe
* @param uref uref structure
* @param upump_p reference to pump that generated the buffer
* @return false if the input must be blocked
*/
static bool upipe_ts_pese_handle(struct upipe *upipe, struct uref *uref,
struct upump **upump_p)
{
struct upipe_ts_pese *upipe_ts_pese = upipe_ts_pese_from_upipe(upipe);
const char *def;
if (unlikely(ubase_check(uref_flow_get_def(uref, &def)))) {
upipe_ts_pese_work(upipe, NULL);
uref_ts_flow_get_pes_id(uref, &upipe_ts_pese->pes_id);
upipe_ts_pese->pes_header_size = 0;
uref_ts_flow_get_pes_header(uref, &upipe_ts_pese->pes_header_size);
upipe_ts_pese->pes_min_duration = 0;
uref_ts_flow_get_pes_min_duration(uref,
&upipe_ts_pese->pes_min_duration);
upipe_ts_pese->input_latency = 0;
uref_clock_get_latency(uref, &upipe_ts_pese->input_latency);
if (unlikely(!ubase_check(uref_clock_set_latency(uref,
upipe_ts_pese->input_latency +
upipe_ts_pese->pes_min_duration))))
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
upipe_ts_pese_store_flow_def(upipe, NULL);
upipe_ts_pese_require_ubuf_mgr(upipe, uref);
return true;
}
if (upipe_ts_pese->flow_def == NULL)
return false;
uint64_t uref_duration = upipe_ts_pese->pes_min_duration;
uref_clock_get_duration(uref, &uref_duration);
size_t uref_size = 0;
uref_block_size(uref, &uref_size);
uref_block_delete_start(uref);
ulist_add(&upipe_ts_pese->next_pes, uref_to_uchain(uref));
upipe_ts_pese->next_pes_duration += uref_duration;
upipe_ts_pese->next_pes_size += uref_size;
if (upipe_ts_pese->next_pes_duration >= upipe_ts_pese->pes_min_duration)
upipe_ts_pese_work(upipe, upump_p);
return true;
}
/** @internal @This parses A/52 header.
*
* @param upipe description structure of the pipe
* @return false in case the header is inconsistent
*/
static bool upipe_a52f_parse_a52(struct upipe *upipe)
{
struct upipe_a52f *upipe_a52f = upipe_a52f_from_upipe(upipe);
uint8_t header[A52_SYNCINFO_SIZE + 2];
if (unlikely(!ubase_check(uref_block_extract(upipe_a52f->next_uref, 0,
sizeof(header), header))))
return true; /* not enough data */
ssize_t next_frame_size = a52_get_frame_size(a52_get_fscod(header),
a52_get_frmsizecod(header));
if (!next_frame_size)
return false;
if (likely(a52_sync_compare_formats(header, upipe_a52f->sync_header) &&
header[5] == upipe_a52f->sync_header[5] &&
header[6] == upipe_a52f->sync_header[6])) {
/* identical sync */
upipe_a52f->next_frame_size = next_frame_size;
return true;
}
/* sample rate */
uint64_t samplerate;
switch (a52_get_fscod(header)) {
case A52_FSCOD_48KHZ:
samplerate = 48000;
break;
case A52_FSCOD_441KHZ:
samplerate = 44100;
break;
case A52_FSCOD_32KHZ:
samplerate = 32000;
break;
default:
upipe_warn(upipe, "reserved fscod");
return false;
}
/* frame size */
upipe_a52f->next_frame_size = next_frame_size;
/* channels */
int acmod = a52_get_acmod(header);
int channels = acmod_chans[acmod].nfchans +
((header[6] >> (4 - acmod_chans[acmod].lfe_offset)) & 1);
uint64_t octetrate = a52_bitrate_tab[a52_get_frmsizecod(header)] * 1000 / 8;
memcpy(upipe_a52f->sync_header, header, A52_SYNCINFO_SIZE + 2);
upipe_a52f->samplerate = samplerate;
struct uref *flow_def = upipe_a52f_alloc_flow_def_attr(upipe);
if (unlikely(!flow_def)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return false;
}
UBASE_FATAL(upipe, uref_flow_set_complete(flow_def))
UBASE_FATAL(upipe, uref_flow_set_def(flow_def, "block.ac3.sound."))
UBASE_FATAL(upipe, uref_sound_flow_set_samples(flow_def, A52_FRAME_SAMPLES))
UBASE_FATAL(upipe, uref_sound_flow_set_rate(flow_def, samplerate))
UBASE_FATAL(upipe, uref_sound_flow_set_channels(flow_def, channels))
UBASE_FATAL(upipe, uref_clock_set_latency(flow_def,
upipe_a52f->input_latency +
UCLOCK_FREQ * A52_FRAME_SAMPLES / samplerate))
UBASE_FATAL(upipe, uref_block_flow_set_octetrate(flow_def, octetrate))
flow_def = upipe_a52f_store_flow_def_attr(upipe, flow_def);
if (unlikely(!flow_def)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return false;
}
upipe_a52f_store_flow_def(upipe, flow_def);
return true;
}
/** @internal @This parses A/52 Annex E header.
*
* @param upipe description structure of the pipe
* @return false in case the header is inconsistent
*/
static bool upipe_a52f_parse_a52e(struct upipe *upipe)
{
struct upipe_a52f *upipe_a52f = upipe_a52f_from_upipe(upipe);
uint8_t header[A52_SYNCINFO_SIZE];
if (unlikely(!ubase_check(uref_block_extract(upipe_a52f->next_uref, 0,
sizeof(header), header))))
return true; /* not enough data */
if (likely(a52e_sync_compare_formats(header, upipe_a52f->sync_header))) {
/* identical sync */
upipe_a52f->next_frame_size =
a52e_get_frame_size(a52e_get_frmsiz(header));
return true;
}
/* sample rate */
uint64_t samplerate;
switch (a52e_get_fscod(header)) {
case A52_FSCOD_48KHZ:
samplerate = 48000;
break;
case A52_FSCOD_441KHZ:
samplerate = 44100;
break;
case A52_FSCOD_32KHZ:
samplerate = 32000;
break;
case A52_FSCOD_RESERVED:
switch (a52e_get_fscod2(header)) {
case A52E_FSCOD2_24KHZ:
samplerate = 24000;
break;
case A52E_FSCOD2_2205KHZ:
samplerate = 22050;
break;
case A52E_FSCOD2_16KHZ:
samplerate = 16000;
break;
default:
upipe_warn(upipe, "reserved fscod2");
return false;
}
break;
default: /* never reached */
return false;
}
/* frame size */
upipe_a52f->next_frame_size = a52e_get_frame_size(a52e_get_frmsiz(header));
/* channels */
int acmod = a52e_get_acmod(header);
int channels = acmod_chans[acmod].nfchans + a52e_get_lfeon(header);
uint64_t octetrate =
(upipe_a52f->next_frame_size * samplerate + A52_FRAME_SAMPLES - 1) /
A52_FRAME_SAMPLES;
memcpy(upipe_a52f->sync_header, header, A52_SYNCINFO_SIZE);
upipe_a52f->samplerate = samplerate;
struct uref *flow_def = upipe_a52f_alloc_flow_def_attr(upipe);
if (unlikely(!flow_def)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return false;
}
UBASE_FATAL(upipe, uref_flow_set_complete(flow_def))
UBASE_FATAL(upipe, uref_flow_set_def(flow_def, "block.eac3.sound."))
UBASE_FATAL(upipe, uref_sound_flow_set_samples(flow_def, A52_FRAME_SAMPLES))
UBASE_FATAL(upipe, uref_sound_flow_set_rate(flow_def, samplerate))
UBASE_FATAL(upipe, uref_sound_flow_set_channels(flow_def, channels))
UBASE_FATAL(upipe, uref_clock_set_latency(flow_def,
upipe_a52f->input_latency +
UCLOCK_FREQ * A52_FRAME_SAMPLES / samplerate))
UBASE_FATAL(upipe, uref_block_flow_set_octetrate(flow_def, octetrate))
flow_def = upipe_a52f_store_flow_def_attr(upipe, flow_def);
if (unlikely(!flow_def)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return false;
}
upipe_a52f_store_flow_def(upipe, flow_def);
return true;
}