/** @internal @This handles data.
*
* @param upipe description structure of the pipe
* @param uref uref structure describing the picture
* @param upump_p reference to pump that generated the buffer
* @return true if the packet was handled
*/
static bool upipe_audiobar_handle(struct upipe *upipe, struct uref *uref,
struct upump **upump_p)
{
struct upipe_audiobar *upipe_audiobar = upipe_audiobar_from_upipe(upipe);
const char *def;
if (unlikely(ubase_check(uref_flow_get_def(uref, &def)))) {
UBASE_FATAL(upipe,
uref_sound_flow_get_channels(uref, &upipe_audiobar->channels))
uref_sound_flow_clear_format(uref);
UBASE_FATAL(upipe,
uref_attr_import(uref, upipe_audiobar->flow_def_config))
uref_pic_flow_clear_format(uref);
UBASE_FATAL(upipe, uref_pic_flow_set_planes(uref, 0))
UBASE_FATAL(upipe, uref_pic_flow_set_macropixel(uref, 1))
UBASE_FATAL(upipe, uref_pic_flow_add_plane(uref, 1, 1, 1, "y8"))
UBASE_FATAL(upipe, uref_pic_flow_add_plane(uref, 2, 1, 1, "u8"))
UBASE_FATAL(upipe, uref_pic_flow_add_plane(uref, 2, 1, 1, "v8"))
UBASE_FATAL(upipe, uref_pic_flow_add_plane(uref, 1, 1, 1, "a8"))
UBASE_FATAL(upipe, uref_pic_set_progressive(uref))
upipe_audiobar->hsize = upipe_audiobar->vsize =
upipe_audiobar->sep_width = upipe_audiobar->pad_width = UINT64_MAX;
upipe_audiobar_require_flow_format(upipe, uref);
return true;
}
if (!upipe_audiobar->ubuf_mgr)
return false;
if (unlikely(upipe_audiobar->hsize == UINT64_MAX))
return false;
struct ubuf *ubuf = ubuf_pic_alloc(upipe_audiobar->ubuf_mgr,
upipe_audiobar->hsize,
upipe_audiobar->vsize);
uref_attach_ubuf(uref, ubuf);
uint8_t *dst[4];
size_t strides[4];
uint8_t hsubs[4];
uint8_t vsubs[4];
static const char *chroma[4] = { "y8", "u8", "v8", "a8" };
for (int i = 0; i < 4; i++) {
if (unlikely(!ubase_check(uref_pic_plane_write(uref, chroma[i],
0, 0, -1, -1, &dst[i])) ||
!ubase_check(uref_pic_plane_size(uref, chroma[i],
&strides[i], &hsubs[i], &vsubs[i], NULL)))) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
uref_free(uref);
return true;
}
}
uint8_t alpha = upipe_audiobar->alpha;
uint64_t h = upipe_audiobar->vsize;
const int hred = h - (iec_scale(-8.) * h);
const int hyellow = h - (iec_scale(-18.) * h);
uint8_t transparent[4] = { 0x10, 0x80, 0x80, 0 };
uint8_t black[4] = { 0x10, 0x80, 0x80, alpha };
uint8_t red[2][4] = { { 76, 85, 0xff, alpha }, { 37, 106, 191, alpha } };
uint8_t green[2][4] = { { 150, 44, 21, alpha }, { 74, 85, 74, alpha } };
uint8_t yellow[2][4] = { { 226, 1, 148, alpha }, { 112, 64, 138, alpha } };
uint64_t pts = 0;
if (unlikely(!ubase_check(uref_clock_get_pts_prog(uref, &pts)))) {
upipe_warn(upipe, "unable to read pts");
}
for (uint8_t chan = 0; chan < upipe_audiobar->channels; chan++) {
double amplitude = 0.;
if (unlikely(!ubase_check(uref_amax_get_amplitude(uref, &litude,
chan))))
upipe_warn_va(upipe, "unable to get amplitude for channel %"PRIu8", assuming silence", chan);
double scale = log10(amplitude) * 20;
// IEC-268-18 return time speed is 20dB per 1.7s (+/- .3)
if (upipe_audiobar->peak_date[chan])
upipe_audiobar->peak[chan] -= 20 * (pts - upipe_audiobar->peak_date[chan]) / (1.7 * UCLOCK_FREQ);
upipe_audiobar->peak_date[chan] = pts;
if (scale >= upipe_audiobar->peak[chan]) /* higher than lowered peak */
upipe_audiobar->peak[chan] = scale;
else /* Current amplitude can not go below the lowered peak value */
scale = upipe_audiobar->peak[chan];
scale = iec_scale(scale);
const int hmax = h - scale * h;
for (int row = 0; row < h; row++) {
bool bright = row > hmax;
const uint8_t *color = row < hred ? red[!bright] :
row < hyellow ? yellow[!bright] :
green[!bright];
copy_color(dst, strides, hsubs, vsubs, color, row,
chan * upipe_audiobar->chan_width,
upipe_audiobar->chan_width);
if (chan && upipe_audiobar->sep_width)
copy_color(dst, strides, hsubs, vsubs, black, row,
chan * upipe_audiobar->chan_width -
upipe_audiobar->sep_width / 2,
upipe_audiobar->sep_width);
if (chan == upipe_audiobar->channels - 1 &&
upipe_audiobar->pad_width)
copy_color(dst, strides, hsubs, vsubs, transparent, row,
(chan + 1) * upipe_audiobar->chan_width,
upipe_audiobar->pad_width);
}
}
/* dB marks */
for (int i = 1; i <= 6; i++) {
int row = h - (iec_scale(-10 * i) * h);
copy_color(dst, strides, hsubs, vsubs, black, row, 0,
upipe_audiobar->hsize);
}
for (int i = 0; i < 4; i++)
ubuf_pic_plane_unmap(ubuf, chroma[i], 0, 0, -1, -1);
upipe_audiobar_output(upipe, uref, upump_p);
return true;
}
/** @internal @This outputs video frames
*
* @param upipe description structure of the pipe
* @param frame AVFrame structure
* @param upump upump structure
*/
static void upipe_avcdec_output_frame(struct upipe *upipe, AVFrame *frame,
struct upump *upump)
{
struct ubuf *ubuf;
struct upipe_avcdec *upipe_avcdec = upipe_avcdec_from_upipe(upipe);
const struct upipe_av_plane *planes = upipe_avcdec->pixfmt->planes;
struct uref *uref = uref_dup(frame->opaque);
uint8_t *data, *src, hsub, vsub;
const char *chroma = NULL;
size_t sstride, dstride;
int i, j;
struct urational aspect;
/* if uref has no attached ubuf (ie DR not supported) */
if (unlikely(!uref->ubuf)) {
ubuf = ubuf_pic_alloc(upipe_avcdec->ubuf_mgr, frame->width, frame->height);
if (!ubuf) {
upipe_throw_aerror(upipe);
return;
}
/* iterate through planes and copy data */
i = j = 0;
for (i=0; i < 4 && (chroma = planes[i].chroma); i++) {
ubuf_pic_plane_write(ubuf, chroma, 0, 0, -1, -1, &data);
ubuf_pic_plane_size(ubuf, chroma, &dstride, &hsub, &vsub, NULL);
src = frame->data[i];
sstride = frame->linesize[i];
for (j = 0; j < frame->height/vsub; j++) {
memcpy(data, src, frame->width/hsub);
data += dstride;
src += sstride;
}
ubuf_pic_plane_unmap(ubuf, chroma, 0, 0, -1, -1);
}
uref_attach_ubuf(uref, ubuf);
}
/* set aspect-ratio */
aspect.den = 0; /* null denom is invalid */
if (upipe_avcdec->context->sample_aspect_ratio.den) {
aspect.num = upipe_avcdec->context->sample_aspect_ratio.num;
aspect.den = upipe_avcdec->context->sample_aspect_ratio.den;
} else if (frame->sample_aspect_ratio.den) {
aspect.num = frame->sample_aspect_ratio.num;
aspect.den = frame->sample_aspect_ratio.den;
}
if (aspect.den) {
urational_simplify(&aspect);
uref_pic_set_aspect(uref, aspect);
}
if (!upipe_avcdec->output_flow) {
struct uref *outflow = uref_pic_flow_alloc_def(upipe_avcdec->uref_mgr, 1);
upipe_avcdec_store_flow_def(upipe, outflow);
}
/* index rap attribute */
upipe_avcdec_set_index_rap(upipe, uref);
upipe_avcdec_output(upipe, uref, upump);
}
/** @internal @This handles the input uref.
*
* @param upipe description structure of the pipe
* @param uref input uref
* @param upump_p reference to pump that generated the buffer
*/
static void upipe_vblk_input(struct upipe *upipe,
struct uref *uref,
struct upump **upump_p)
{
struct upipe_vblk *upipe_vblk = upipe_vblk_from_upipe(upipe);
struct uref *flow_def = upipe_vblk->flow_def;
struct uref *input_flow_def = upipe_vblk->input_flow_def;
if (uref->ubuf) {
upipe_vblk_output(upipe, uref, upump_p);
return;
}
if (unlikely(!input_flow_def)) {
upipe_warn(upipe, "no input flow definition");
uref_free(uref);
return;
}
if (unlikely(!flow_def)) {
upipe_warn(upipe, "no output flow definition");
uref_free(uref);
return;
}
if (unlikely(!upipe_vblk->ubuf_mgr)) {
upipe_warn(upipe, "no ubuf manager set");
uref_free(uref);
return;
}
if (unlikely(!upipe_vblk->ubuf)) {
upipe_verbose(upipe, "allocate blank picture");
uint64_t hsize, vsize;
ubase_assert(uref_pic_flow_get_hsize(upipe_vblk->flow_def, &hsize));
ubase_assert(uref_pic_flow_get_vsize(upipe_vblk->flow_def, &vsize));
upipe_vblk->ubuf = ubuf_pic_alloc(upipe_vblk->ubuf_mgr, hsize, vsize);
if (unlikely(!upipe_vblk->ubuf)) {
upipe_err(upipe, "fail to allocate picture");
uref_free(uref);
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return;
}
ubuf_pic_clear(upipe_vblk->ubuf, 0, 0, -1, -1, 1);
}
struct ubuf *ubuf = ubuf_dup(upipe_vblk->ubuf);
if (unlikely(!ubuf)) {
upipe_err(upipe, "fail to duplicate blank picture");
uref_free(uref);
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return;
}
uref_attach_ubuf(uref, ubuf);
if (ubase_check(uref_pic_get_progressive(flow_def)))
uref_pic_set_progressive(uref);
upipe_vblk_output(upipe, uref, upump_p);
}
/** @internal @This is called by avcodec when allocating a new frame
* @param context current avcodec context
* @param frame avframe handler entering avcodec black magic box
*/
static int upipe_avcdec_get_buffer(struct AVCodecContext *context, AVFrame *frame)
{
struct upipe *upipe = context->opaque;
struct upipe_avcdec *upipe_avcdec = upipe_avcdec_from_upipe(upipe);
struct ubuf *ubuf_pic;
int width_aligned, height_aligned, i;
const struct upipe_av_plane *planes = NULL;
size_t stride = 0;
frame->opaque = uref_dup(upipe_avcdec->uref);
uint64_t framenum = 0;
uref_pic_get_number(frame->opaque, &framenum);
upipe_dbg_va(upipe, "Allocating frame for %u (%p) - %ux%u",
framenum, frame->opaque, frame->width, frame->height);
if (unlikely(!upipe_avcdec->pixfmt)) {
upipe_avcdec->pixfmt = upipe_av_pixfmt_from_ubuf_mgr(upipe_avcdec->ubuf_mgr);
if (unlikely(!upipe_avcdec->pixfmt)) {
upipe_err_va(upipe, "frame format of ubuf manager not recognized");
return 0;
}
}
if (context->pix_fmt != *upipe_avcdec->pixfmt->pixfmt) {
upipe_err_va(upipe, "frame format not compatible (%s != %s",
av_get_pix_fmt_name(context->pix_fmt),
av_get_pix_fmt_name(*upipe_avcdec->pixfmt->pixfmt));
return 0;
}
planes = upipe_avcdec->pixfmt->planes;
/* direct rendering - allocate ubuf pic */
if (upipe_avcdec->context->codec->capabilities & CODEC_CAP_DR1) {
width_aligned = context->width;
height_aligned = context->height;
/* use avcodec width/height alignement, then resize pic */
avcodec_align_dimensions(context, &width_aligned, &height_aligned);
ubuf_pic = ubuf_pic_alloc(upipe_avcdec->ubuf_mgr, width_aligned, height_aligned);
if (likely(ubuf_pic)) {
ubuf_pic_resize(ubuf_pic, 0, 0, context->width, context->height);
uref_attach_ubuf(frame->opaque, ubuf_pic);
for (i=0; i < 4 && planes[i].chroma; i++) {
ubuf_pic_plane_write(ubuf_pic, planes[i].chroma,
0, 0, -1, -1, &frame->data[i]);
ubuf_pic_plane_size(ubuf_pic, planes[i].chroma, &stride,
NULL, NULL, NULL);
frame->linesize[i] = stride;
}
frame->extended_data = frame->data;
frame->type = FF_BUFFER_TYPE_USER;
return 1; /* success */
} else {
upipe_dbg_va(upipe, "ubuf_pic_alloc(%d, %d) failed, fallback", width_aligned, height_aligned);
}
}
/* default : DR failed or not available */
return avcodec_default_get_buffer(context, frame);
}
/** @internal @This handles input.
*
* @param upipe description structure of the pipe
* @param uref uref structure
* @param upump_p reference to upump structure
* @return always true
*/
static bool upipe_filter_blend_handle(struct upipe *upipe, struct uref *uref,
struct upump **upump_p)
{
struct upipe_filter_blend *upipe_filter_blend = upipe_filter_blend_from_upipe(upipe);
const char *def;
if (unlikely(ubase_check(uref_flow_get_def(uref, &def)))) {
upipe_filter_blend_store_flow_def(upipe, NULL);
upipe_filter_blend_require_ubuf_mgr(upipe, uref);
return true;
}
if (upipe_filter_blend->flow_def == NULL)
return false;
const uint8_t *in;
uint8_t *out;
uint8_t hsub, vsub, macropixel_size;
size_t stride_in = 0, stride_out = 0, width, height;
const char *chroma = NULL;
struct ubuf *ubuf_deint = NULL;
// Now process frames
uref_pic_size(uref, &width, &height, NULL);
upipe_verbose_va(upipe, "received pic (%zux%zu)", width, height);
assert(upipe_filter_blend->ubuf_mgr);
ubuf_deint = ubuf_pic_alloc(upipe_filter_blend->ubuf_mgr, width, height);
if (unlikely(!ubuf_deint)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
goto error;
}
// Iterate planes
while (ubase_check(uref_pic_plane_iterate(uref, &chroma)) && chroma) {
// map all
if (unlikely(!ubase_check(uref_pic_plane_size(uref, chroma, &stride_in,
&hsub, &vsub, ¯opixel_size)))) {
upipe_err_va(upipe, "Could not read origin chroma %s", chroma);
goto error;
}
if (unlikely(!ubase_check(ubuf_pic_plane_size(ubuf_deint, chroma, &stride_out,
NULL, NULL, NULL)))) {
upipe_err_va(upipe, "Could not read dest chroma %s", chroma);
goto error;
}
uref_pic_plane_read(uref, chroma, 0, 0, -1, -1, &in);
ubuf_pic_plane_write(ubuf_deint, chroma, 0, 0, -1, -1, &out);
// process plane
upipe_filter_blend_plane(in, out, stride_in, stride_out, (size_t) height/vsub, macropixel_size);
// unmap all
uref_pic_plane_unmap(uref, chroma, 0, 0, -1, -1);
ubuf_pic_plane_unmap(ubuf_deint, chroma, 0, 0, -1, -1);
}
// Attach new ubuf and output frame
uref_attach_ubuf(uref, ubuf_deint);
uref_pic_set_progressive(uref);
uref_pic_delete_tff(uref);
upipe_filter_blend_output(upipe, uref, upump_p);
return true;
error:
uref_free(uref);
if (ubuf_deint) {
ubuf_free(ubuf_deint);
}
return true;
}