static void pic_fill_in(struct ubuf *ubuf)
{
size_t hsize, vsize;
uint8_t macropixel;
ubase_assert(ubuf_pic_size(ubuf, &hsize, &vsize, ¯opixel));
const char *chroma = NULL;
while (ubase_check(ubuf_pic_plane_iterate(ubuf, &chroma)) &&
chroma != NULL) {
size_t stride;
uint8_t hsub, vsub, macropixel_size;
ubase_assert(ubuf_pic_plane_size(ubuf, chroma, &stride, &hsub, &vsub,
¯opixel_size));
int hoctets = hsize * macropixel_size / hsub / macropixel;
uint8_t *buffer;
ubase_assert(ubuf_pic_plane_write(ubuf, chroma, 0, 0, -1, -1, &buffer));
for (int y = 0; y < vsize / vsub; y++) {
for (int x = 0; x < hoctets; x++)
buffer[x] = 1 + (y * hoctets) + x;
buffer += stride;
}
ubase_assert(ubuf_pic_plane_unmap(ubuf, chroma, 0, 0, -1, -1));
}
}
/** @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 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;
}
