static bool upipe_dveo_asi_sink_add_header(struct upipe *upipe, struct uref *uref,
uint64_t pts)
{
struct upipe_dveo_asi_sink *upipe_dveo_asi_sink = upipe_dveo_asi_sink_from_upipe(upipe);
uint64_t hdr_size;
if (!ubase_check(uref_block_get_header_size(uref, &hdr_size)))
hdr_size = 0;
if (hdr_size != 0)
return false;
/* alloc header */
struct ubuf *header = ubuf_block_alloc(uref->ubuf->mgr, 8);
if (unlikely(!header)) {
return true;
}
/* 63-bits timestamp */
union {
uint8_t timestamp[8];
uint64_t pts;
} timestamp;
timestamp.pts = pts;
if (upipe_dveo_asi_sink->first_timestamp) {
upipe_dveo_asi_sink->first_timestamp = false;
// FIXME: set the counter in an empty packet, and account for latency
timestamp.pts |= 1LLU << 63; /* Set MSB = Set the counter */
}
/* write header, 64 bits little-endian :
* https://github.com/kierank/dveo-linux-master/blob/450e4b9e4292c2f71acd4d3d2e0a0cd0879d473a/doc/ASI/features.txt#L62 */
int size = 8;
uint8_t *header_write_ptr;
if (!ubase_check(ubuf_block_write(header, 0, &size, &header_write_ptr))) {
upipe_err(upipe, "could not write header");
ubuf_free(header);
return true;
}
memcpy(header_write_ptr, timestamp.timestamp, 8);
uref_block_unmap(uref, 0);
/* append payload (current ubuf) to header to form segmented ubuf */
struct ubuf *payload = uref_detach_ubuf(uref);
if (unlikely(!ubase_check(ubuf_block_append(header, payload)))) {
upipe_warn(upipe, "could not append payload to header");
ubuf_free(header);
ubuf_free(payload);
return true;
}
uref_attach_ubuf(uref, header);
uref_block_set_header_size(uref, 8);
return false;
}
/** @internal @This is called by avcodec when allocating a new audio buffer
* Used with audio decoders.
* @param context current avcodec context
* @param frame avframe handler entering avcodec black magic box
*/
static int upipe_avcdec_get_buffer_audio(struct AVCodecContext *context, AVFrame *frame)
{
struct upipe *upipe = context->opaque;
struct upipe_avcdec *upipe_avcdec = upipe_avcdec_from_upipe(upipe);
struct ubuf *ubuf_samples;
uint8_t *buf;
int size;
frame->opaque = uref_dup(upipe_avcdec->uref);
/* direct rendering - allocate ubuf for audio */
if (upipe_avcdec->context->codec->capabilities & CODEC_CAP_DR1) {
ubuf_samples = ubuf_block_alloc(upipe_avcdec->ubuf_mgr,
av_samples_get_buffer_size(NULL, context->channels,
frame->nb_samples, context->sample_fmt, 1));
if (likely(ubuf_samples)) {
ubuf_block_write(ubuf_samples, 0, &size, &buf);
uref_attach_ubuf(frame->opaque, ubuf_samples);
av_samples_fill_arrays(frame->data, frame->linesize, buf,
context->channels, frame->nb_samples, context->sample_fmt, 1);
frame->extended_data = frame->data;
frame->type = FF_BUFFER_TYPE_USER;
return 1; /* success */
} else {
upipe_dbg_va(upipe, "ubuf allocation failed, fallback");
}
}
/* default : DR failed or not available */
return avcodec_default_get_buffer(context, frame);
}
/** @internal @This outputs audio buffers
*
* @param upipe description structure of the pipe
* @param frame AVFrame structure
* @param upump upump structure
*/
static void upipe_avcdec_output_audio(struct upipe *upipe, AVFrame *frame,
struct upump *upump)
{
struct ubuf *ubuf;
struct upipe_avcdec *upipe_avcdec = upipe_avcdec_from_upipe(upipe);
struct uref *uref = frame->opaque;
int bufsize = -1, avbufsize;
size_t size = 0;
uint8_t *buf;
AVCodecContext *context = upipe_avcdec->context;
/* fetch audio sample size (in case it has been reduced) */
avbufsize = av_samples_get_buffer_size(NULL, context->channels,
frame->nb_samples, context->sample_fmt, 1);
/* if uref has no attached ubuf (ie DR not supported) */
if (unlikely(!uref->ubuf)) {
ubuf = ubuf_block_alloc(upipe_avcdec->ubuf_mgr, avbufsize);
if (unlikely(!ubuf)) {
upipe_throw_aerror(upipe);
return;
}
ubuf_block_write(ubuf, 0, &bufsize, &buf);
memcpy(buf, frame->data[0], bufsize);
uref_attach_ubuf(uref, ubuf);
}
/* unmap, reduce block if needed */
uref_block_unmap(uref, 0);
uref_block_size(uref, &size);
if (unlikely(size != avbufsize)) {
uref_block_resize(uref, 0, avbufsize);
}
/* TODO: set attributes/need a real ubuf_audio structure (?) */
if (!upipe_avcdec->output_flow) {
#if 0
struct uref *outflow = uref_sound_flow_alloc_def(upipe_avcdec->uref_mgr,
context->channels,
av_get_bytes_per_sample(context->sample_fmt));
#else
struct uref *outflow = uref_block_flow_alloc_def(upipe_avcdec->uref_mgr,
"sound.");
#endif
uref_sound_flow_set_channels(outflow, context->channels);
uref_sound_flow_set_sample_size(outflow,
av_get_bytes_per_sample(context->sample_fmt));
uref_sound_flow_set_rate(outflow, context->sample_rate);
upipe_avcdec_store_flow_def(upipe, outflow);
}
/* samples in uref */
uref_sound_flow_set_samples(uref, frame->nb_samples);
/* index rap attribute */
upipe_avcdec_set_index_rap(upipe, uref);
upipe_avcdec_output(upipe, uref, upump);
}
static void upipe_rtp_h264_output_nalu(struct upipe *upipe,
uint8_t nalu,
struct uref *uref,
struct upump **upump_p)
{
size_t size = 0;
if (unlikely(!ubase_check(uref_block_size(uref, &size)))) {
upipe_err(upipe, "fail to get block size");
return;
}
bool split = size > RTP_SPLIT_SIZE;
uint32_t fragment = 0;
while (size) {
bool last_fragment = size <= RTP_SPLIT_SIZE;
size_t split_size = last_fragment ? size : RTP_SPLIT_SIZE;
uint8_t hdr[2] = { nalu, 0 };
size_t hdr_size = 1;
if (split) {
if (!fragment)
hdr[1] = FU_START;
else if (last_fragment)
hdr[1] = FU_END;
hdr[1] |= NALU_TYPE(hdr[0]);
hdr[0] = NALU_F(hdr[0]) | NALU_NRI(hdr[0]) | FU_A;
hdr_size++;
}
struct uref *next = NULL;
if (!last_fragment) {
next = uref_block_split(uref, split_size);
if (unlikely(next == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return;
}
}
/* FIXME should require a ubuf_mgr */
struct ubuf *header =
ubuf_block_alloc(uref->ubuf->mgr, hdr_size * sizeof (hdr[0]));
if (unlikely(header == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
uref_free(uref);
uref_free(next);
return;
}
uint8_t *buf = NULL;
int buf_size = hdr_size;
ubuf_block_write(header, 0, &buf_size, &buf);
memcpy(buf, hdr, hdr_size * sizeof (hdr[0]));
ubuf_block_unmap(header, 0);
/* append payload (current ubuf) to header to form segmented ubuf */
struct ubuf *payload = uref_detach_ubuf(uref);
if (unlikely(!ubase_check(ubuf_block_append(header, payload)))) {
upipe_warn(upipe, "could not append payload to header");
ubuf_free(header);
ubuf_free(payload);
uref_free(uref);
uref_free(next);
return;
}
uref_attach_ubuf(uref, header);
uref_clock_set_cr_dts_delay(uref, 0);
upipe_rtp_h264_output(upipe, uref, upump_p);
size -= split_size;
fragment++;
uref = next;
}
}
/** @internal @This handles data from sound allocator.
*
* @param upipe description structure of the pipe
* @param uref uref structure
* @param upump_p reference to pump that generated the buffer
*/
static void upipe_tblk_handle_sound(struct upipe *upipe, struct uref *uref,
struct upump **upump_p)
{
struct upipe_tblk *upipe_tblk = upipe_tblk_from_upipe(upipe);
/* Always operate on the first channel plane. */
const char *channel = NULL;
if (unlikely(uref->ubuf == NULL ||
!ubase_check(ubuf_sound_plane_iterate(uref->ubuf, &channel)) ||
channel == NULL)) {
uref_free(uref);
upipe_throw_error(upipe, UBASE_ERR_INVALID);
return;
}
/* First try the ubuf_mem_shared method. */
struct ubuf *ubuf = ubuf_block_mem_alloc_from_sound(upipe_tblk->ubuf_mgr,
uref->ubuf, channel);
if (unlikely(ubuf == NULL)) {
/* We have to memcpy the thing. */
size_t samples;
uint8_t sample_size;
if (unlikely(!ubase_check(uref_sound_size(uref, &samples,
&sample_size)))) {
uref_free(uref);
upipe_throw_error(upipe, UBASE_ERR_INVALID);
return;
}
size_t size = samples * sample_size;
ubuf = ubuf_block_alloc(upipe_tblk->ubuf_mgr, size);
if (unlikely(ubuf == NULL)) {
uref_free(uref);
upipe_throw_error(upipe, UBASE_ERR_ALLOC);
return;
}
const uint8_t *r;
if (unlikely(!ubase_check(uref_sound_plane_read_uint8_t(uref, channel,
0, -1, &r)))) {
ubuf_free(ubuf);
uref_free(uref);
upipe_throw_error(upipe, UBASE_ERR_ALLOC);
return;
}
uint8_t *w;
int end = -1;
if (unlikely(!ubase_check(ubuf_block_write(ubuf, 0, &end, &w)))) {
uref_sound_plane_unmap(uref, channel, 0, -1);
ubuf_free(ubuf);
uref_free(uref);
upipe_throw_error(upipe, UBASE_ERR_ALLOC);
return;
}
memcpy(w, r, size);
ubuf_block_unmap(ubuf, 0);
uref_sound_plane_unmap(uref, channel, 0, -1);
}
uref_attach_ubuf(uref, ubuf);
upipe_tblk_output(upipe, uref, upump_p);
}
/** @internal @This handles data from pic allocator.
*
* @param upipe description structure of the pipe
* @param uref uref structure
* @param upump_p reference to pump that generated the buffer
*/
static void upipe_tblk_handle_pic(struct upipe *upipe, struct uref *uref,
struct upump **upump_p)
{
struct upipe_tblk *upipe_tblk = upipe_tblk_from_upipe(upipe);
/* Always operate on the first chroma plane. */
const char *chroma = NULL;
if (unlikely(uref->ubuf == NULL ||
!ubase_check(ubuf_pic_plane_iterate(uref->ubuf, &chroma)) ||
chroma == NULL)) {
uref_free(uref);
upipe_throw_error(upipe, UBASE_ERR_INVALID);
return;
}
/* First try the ubuf_mem_shared method. */
struct ubuf *ubuf = ubuf_block_mem_alloc_from_pic(upipe_tblk->ubuf_mgr,
uref->ubuf, chroma);
if (unlikely(ubuf == NULL)) {
/* We have to memcpy the thing. */
size_t hsize, vsize, stride;
uint8_t macropixel, hsub, vsub, macropixel_size;
if (unlikely(!ubase_check(uref_pic_size(uref, NULL, &vsize,
NULL)) ||
!ubase_check(uref_pic_plane_size(uref, chroma,
&stride, NULL, &vsub, NULL)))) {
uref_free(uref);
upipe_throw_error(upipe, UBASE_ERR_INVALID);
return;
}
size_t size = stride * vsize / vsub;
ubuf = ubuf_block_alloc(upipe_tblk->ubuf_mgr, size);
if (unlikely(ubuf == NULL)) {
uref_free(uref);
upipe_throw_error(upipe, UBASE_ERR_ALLOC);
return;
}
const uint8_t *r;
if (unlikely(!ubase_check(uref_pic_plane_read(uref, chroma,
0, 0, -1, -1, &r)))) {
ubuf_free(ubuf);
uref_free(uref);
upipe_throw_error(upipe, UBASE_ERR_ALLOC);
return;
}
uint8_t *w;
int end = -1;
if (unlikely(!ubase_check(ubuf_block_write(ubuf, 0, &end, &w)))) {
uref_pic_plane_unmap(uref, chroma, 0, 0, -1, -1);
ubuf_free(ubuf);
uref_free(uref);
upipe_throw_error(upipe, UBASE_ERR_ALLOC);
return;
}
memcpy(w, r, size);
ubuf_block_unmap(ubuf, 0);
uref_pic_plane_unmap(uref, chroma, 0, 0, -1, -1);
}
uref_attach_ubuf(uref, ubuf);
upipe_tblk_output(upipe, uref, upump_p);
}
/** @internal @This prepends a PES header to a logical unit.
*
* @param upipe description structure of the pipe
* @param upump_p reference to pump that generated the buffer
*/
static void upipe_ts_pese_work(struct upipe *upipe, struct upump **upump_p)
{
struct upipe_ts_pese *upipe_ts_pese = upipe_ts_pese_from_upipe(upipe);
if (ulist_empty(&upipe_ts_pese->next_pes))
return;
uint64_t pts = UINT64_MAX, dts = UINT64_MAX;
struct uref *uref = uref_from_uchain(ulist_pop(&upipe_ts_pese->next_pes));
size_t header_size;
if (upipe_ts_pese->pes_id != PES_STREAM_ID_PRIVATE_2) {
uref_clock_get_pts_prog(uref, &pts);
uref_clock_get_dts_prog(uref, &dts);
if (pts != UINT64_MAX) {
if (dts != UINT64_MAX &&
((pts / CLOCK_SCALE) % POW2_33) !=
((dts / CLOCK_SCALE) % POW2_33))
header_size = PES_HEADER_SIZE_PTSDTS;
else
header_size = PES_HEADER_SIZE_PTS;
} else
header_size = PES_HEADER_SIZE_NOPTS;
} else
header_size = PES_HEADER_SIZE;
if (header_size < upipe_ts_pese->pes_header_size)
header_size = upipe_ts_pese->pes_header_size;
struct ubuf *ubuf = ubuf_block_alloc(upipe_ts_pese->ubuf_mgr, header_size);
if (unlikely(ubuf == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
goto upipe_ts_pese_work_err;
}
uint8_t *buffer;
int size = -1;
if (unlikely(!ubase_check(ubuf_block_write(ubuf, 0, &size, &buffer)))) {
ubuf_free(ubuf);
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
goto upipe_ts_pese_work_err;
}
pes_init(buffer);
pes_set_streamid(buffer, upipe_ts_pese->pes_id);
size_t pes_length = upipe_ts_pese->next_pes_size + header_size -
PES_HEADER_SIZE;
if (pes_length > UINT16_MAX) {
if (unlikely((upipe_ts_pese->pes_id & PES_STREAM_ID_VIDEO_MPEG) !=
PES_STREAM_ID_VIDEO_MPEG))
upipe_warn(upipe, "PES length > 65535 for a non-video stream");
pes_set_length(buffer, 0);
} else
pes_set_length(buffer, pes_length);
if (upipe_ts_pese->pes_id != PES_STREAM_ID_PRIVATE_2) {
pes_set_headerlength(buffer, header_size - PES_HEADER_SIZE_NOPTS);
pes_set_dataalignment(buffer);
if (pts != UINT64_MAX) {
pes_set_pts(buffer, (pts / CLOCK_SCALE) % POW2_33);
if (dts != UINT64_MAX &&
((pts / CLOCK_SCALE) % POW2_33) !=
((dts / CLOCK_SCALE) % POW2_33))
pes_set_dts(buffer, (dts / CLOCK_SCALE) % POW2_33);
}
}
ubuf_block_unmap(ubuf, 0);
struct ubuf *payload = uref_detach_ubuf(uref);
uref_attach_ubuf(uref, ubuf);
if (unlikely(!ubase_check(uref_block_append(uref, payload)))) {
uref_free(uref);
ubuf_free(payload);
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return;
}
/* intended pass-through */
upipe_ts_pese_work_err:
uref_block_set_start(uref);
upipe_ts_pese_output(upipe, uref, upump_p);
struct uchain *uchain;
while ((uchain = ulist_pop(&upipe_ts_pese->next_pes)) != NULL)
upipe_ts_pese_output(upipe, uref_from_uchain(uchain), upump_p);
upipe_ts_pese->next_pes_size = 0;
upipe_ts_pese->next_pes_duration = 0;
}
