575 lines
17 KiB
C
575 lines
17 KiB
C
/*
|
|
* V4L2 buffer helper functions.
|
|
*
|
|
* Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
|
|
* Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
|
|
*
|
|
* This file is part of FFmpeg.
|
|
*
|
|
* FFmpeg is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with FFmpeg; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include <linux/videodev2.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/mman.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <poll.h>
|
|
#include "libavcodec/avcodec.h"
|
|
#include "libavcodec/internal.h"
|
|
#include "libavutil/pixdesc.h"
|
|
#include "v4l2_context.h"
|
|
#include "v4l2_buffers.h"
|
|
#include "v4l2_m2m.h"
|
|
|
|
#define USEC_PER_SEC 1000000
|
|
static AVRational v4l2_timebase = { 1, USEC_PER_SEC };
|
|
|
|
static inline V4L2m2mContext *buf_to_m2mctx(V4L2Buffer *buf)
|
|
{
|
|
return V4L2_TYPE_IS_OUTPUT(buf->context->type) ?
|
|
container_of(buf->context, V4L2m2mContext, output) :
|
|
container_of(buf->context, V4L2m2mContext, capture);
|
|
}
|
|
|
|
static inline AVCodecContext *logger(V4L2Buffer *buf)
|
|
{
|
|
return buf_to_m2mctx(buf)->avctx;
|
|
}
|
|
|
|
static inline AVRational v4l2_get_timebase(V4L2Buffer *avbuf)
|
|
{
|
|
V4L2m2mContext *s = buf_to_m2mctx(avbuf);
|
|
|
|
if (s->avctx->pkt_timebase.num)
|
|
return s->avctx->pkt_timebase;
|
|
return s->avctx->time_base;
|
|
}
|
|
|
|
static inline void v4l2_set_pts(V4L2Buffer *out, int64_t pts)
|
|
{
|
|
int64_t v4l2_pts;
|
|
|
|
if (pts == AV_NOPTS_VALUE)
|
|
pts = 0;
|
|
|
|
/* convert pts to v4l2 timebase */
|
|
v4l2_pts = av_rescale_q(pts, v4l2_get_timebase(out), v4l2_timebase);
|
|
out->buf.timestamp.tv_usec = v4l2_pts % USEC_PER_SEC;
|
|
out->buf.timestamp.tv_sec = v4l2_pts / USEC_PER_SEC;
|
|
}
|
|
|
|
static inline int64_t v4l2_get_pts(V4L2Buffer *avbuf)
|
|
{
|
|
int64_t v4l2_pts;
|
|
|
|
/* convert pts back to encoder timebase */
|
|
v4l2_pts = (int64_t)avbuf->buf.timestamp.tv_sec * USEC_PER_SEC +
|
|
avbuf->buf.timestamp.tv_usec;
|
|
|
|
return av_rescale_q(v4l2_pts, v4l2_timebase, v4l2_get_timebase(avbuf));
|
|
}
|
|
|
|
static enum AVColorPrimaries v4l2_get_color_primaries(V4L2Buffer *buf)
|
|
{
|
|
enum v4l2_ycbcr_encoding ycbcr;
|
|
enum v4l2_colorspace cs;
|
|
|
|
cs = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
|
|
buf->context->format.fmt.pix_mp.colorspace :
|
|
buf->context->format.fmt.pix.colorspace;
|
|
|
|
ycbcr = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
|
|
buf->context->format.fmt.pix_mp.ycbcr_enc:
|
|
buf->context->format.fmt.pix.ycbcr_enc;
|
|
|
|
switch(ycbcr) {
|
|
case V4L2_YCBCR_ENC_XV709:
|
|
case V4L2_YCBCR_ENC_709: return AVCOL_PRI_BT709;
|
|
case V4L2_YCBCR_ENC_XV601:
|
|
case V4L2_YCBCR_ENC_601:return AVCOL_PRI_BT470M;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch(cs) {
|
|
case V4L2_COLORSPACE_470_SYSTEM_BG: return AVCOL_PRI_BT470BG;
|
|
case V4L2_COLORSPACE_SMPTE170M: return AVCOL_PRI_SMPTE170M;
|
|
case V4L2_COLORSPACE_SMPTE240M: return AVCOL_PRI_SMPTE240M;
|
|
case V4L2_COLORSPACE_BT2020: return AVCOL_PRI_BT2020;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return AVCOL_PRI_UNSPECIFIED;
|
|
}
|
|
|
|
static enum AVColorRange v4l2_get_color_range(V4L2Buffer *buf)
|
|
{
|
|
enum v4l2_quantization qt;
|
|
|
|
qt = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
|
|
buf->context->format.fmt.pix_mp.quantization :
|
|
buf->context->format.fmt.pix.quantization;
|
|
|
|
switch (qt) {
|
|
case V4L2_QUANTIZATION_LIM_RANGE: return AVCOL_RANGE_MPEG;
|
|
case V4L2_QUANTIZATION_FULL_RANGE: return AVCOL_RANGE_JPEG;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return AVCOL_RANGE_UNSPECIFIED;
|
|
}
|
|
|
|
static enum AVColorSpace v4l2_get_color_space(V4L2Buffer *buf)
|
|
{
|
|
enum v4l2_ycbcr_encoding ycbcr;
|
|
enum v4l2_colorspace cs;
|
|
|
|
cs = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
|
|
buf->context->format.fmt.pix_mp.colorspace :
|
|
buf->context->format.fmt.pix.colorspace;
|
|
|
|
ycbcr = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
|
|
buf->context->format.fmt.pix_mp.ycbcr_enc:
|
|
buf->context->format.fmt.pix.ycbcr_enc;
|
|
|
|
switch(cs) {
|
|
case V4L2_COLORSPACE_SRGB: return AVCOL_SPC_RGB;
|
|
case V4L2_COLORSPACE_REC709: return AVCOL_SPC_BT709;
|
|
case V4L2_COLORSPACE_470_SYSTEM_M: return AVCOL_SPC_FCC;
|
|
case V4L2_COLORSPACE_470_SYSTEM_BG: return AVCOL_SPC_BT470BG;
|
|
case V4L2_COLORSPACE_SMPTE170M: return AVCOL_SPC_SMPTE170M;
|
|
case V4L2_COLORSPACE_SMPTE240M: return AVCOL_SPC_SMPTE240M;
|
|
case V4L2_COLORSPACE_BT2020:
|
|
if (ycbcr == V4L2_YCBCR_ENC_BT2020_CONST_LUM)
|
|
return AVCOL_SPC_BT2020_CL;
|
|
else
|
|
return AVCOL_SPC_BT2020_NCL;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return AVCOL_SPC_UNSPECIFIED;
|
|
}
|
|
|
|
static enum AVColorTransferCharacteristic v4l2_get_color_trc(V4L2Buffer *buf)
|
|
{
|
|
enum v4l2_ycbcr_encoding ycbcr;
|
|
enum v4l2_xfer_func xfer;
|
|
enum v4l2_colorspace cs;
|
|
|
|
cs = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
|
|
buf->context->format.fmt.pix_mp.colorspace :
|
|
buf->context->format.fmt.pix.colorspace;
|
|
|
|
ycbcr = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
|
|
buf->context->format.fmt.pix_mp.ycbcr_enc:
|
|
buf->context->format.fmt.pix.ycbcr_enc;
|
|
|
|
xfer = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
|
|
buf->context->format.fmt.pix_mp.xfer_func:
|
|
buf->context->format.fmt.pix.xfer_func;
|
|
|
|
switch (xfer) {
|
|
case V4L2_XFER_FUNC_709: return AVCOL_TRC_BT709;
|
|
case V4L2_XFER_FUNC_SRGB: return AVCOL_TRC_IEC61966_2_1;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (cs) {
|
|
case V4L2_COLORSPACE_470_SYSTEM_M: return AVCOL_TRC_GAMMA22;
|
|
case V4L2_COLORSPACE_470_SYSTEM_BG: return AVCOL_TRC_GAMMA28;
|
|
case V4L2_COLORSPACE_SMPTE170M: return AVCOL_TRC_SMPTE170M;
|
|
case V4L2_COLORSPACE_SMPTE240M: return AVCOL_TRC_SMPTE240M;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (ycbcr) {
|
|
case V4L2_YCBCR_ENC_XV709:
|
|
case V4L2_YCBCR_ENC_XV601: return AVCOL_TRC_BT1361_ECG;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return AVCOL_TRC_UNSPECIFIED;
|
|
}
|
|
|
|
static void v4l2_free_buffer(void *opaque, uint8_t *unused)
|
|
{
|
|
V4L2Buffer* avbuf = opaque;
|
|
V4L2m2mContext *s = buf_to_m2mctx(avbuf);
|
|
|
|
if (atomic_fetch_sub(&avbuf->context_refcount, 1) == 1) {
|
|
atomic_fetch_sub_explicit(&s->refcount, 1, memory_order_acq_rel);
|
|
|
|
if (s->reinit) {
|
|
if (!atomic_load(&s->refcount))
|
|
sem_post(&s->refsync);
|
|
} else {
|
|
if (s->draining && V4L2_TYPE_IS_OUTPUT(avbuf->context->type)) {
|
|
/* no need to queue more buffers to the driver */
|
|
avbuf->status = V4L2BUF_AVAILABLE;
|
|
}
|
|
else if (avbuf->context->streamon)
|
|
ff_v4l2_buffer_enqueue(avbuf);
|
|
}
|
|
|
|
av_buffer_unref(&avbuf->context_ref);
|
|
}
|
|
}
|
|
|
|
static int v4l2_buf_increase_ref(V4L2Buffer *in)
|
|
{
|
|
V4L2m2mContext *s = buf_to_m2mctx(in);
|
|
|
|
if (in->context_ref)
|
|
atomic_fetch_add(&in->context_refcount, 1);
|
|
else {
|
|
in->context_ref = av_buffer_ref(s->self_ref);
|
|
if (!in->context_ref)
|
|
return AVERROR(ENOMEM);
|
|
|
|
in->context_refcount = 1;
|
|
}
|
|
|
|
in->status = V4L2BUF_RET_USER;
|
|
atomic_fetch_add_explicit(&s->refcount, 1, memory_order_relaxed);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int v4l2_buf_to_bufref(V4L2Buffer *in, int plane, AVBufferRef **buf)
|
|
{
|
|
int ret;
|
|
|
|
if (plane >= in->num_planes)
|
|
return AVERROR(EINVAL);
|
|
|
|
/* even though most encoders return 0 in data_offset encoding vp8 does require this value */
|
|
*buf = av_buffer_create((char *)in->plane_info[plane].mm_addr + in->planes[plane].data_offset,
|
|
in->plane_info[plane].length, v4l2_free_buffer, in, 0);
|
|
if (!*buf)
|
|
return AVERROR(ENOMEM);
|
|
|
|
ret = v4l2_buf_increase_ref(in);
|
|
if (ret)
|
|
av_buffer_unref(buf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int v4l2_bufref_to_buf(V4L2Buffer *out, int plane, const uint8_t* data, int size, int offset, AVBufferRef* bref)
|
|
{
|
|
unsigned int bytesused, length;
|
|
|
|
if (plane >= out->num_planes)
|
|
return AVERROR(EINVAL);
|
|
|
|
length = out->plane_info[plane].length;
|
|
bytesused = FFMIN(size+offset, length);
|
|
|
|
memcpy((uint8_t*)out->plane_info[plane].mm_addr+offset, data, FFMIN(size, length-offset));
|
|
|
|
if (V4L2_TYPE_IS_MULTIPLANAR(out->buf.type)) {
|
|
out->planes[plane].bytesused = bytesused;
|
|
out->planes[plane].length = length;
|
|
} else {
|
|
out->buf.bytesused = bytesused;
|
|
out->buf.length = length;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int v4l2_buffer_buf_to_swframe(AVFrame *frame, V4L2Buffer *avbuf)
|
|
{
|
|
int i, ret;
|
|
|
|
frame->format = avbuf->context->av_pix_fmt;
|
|
|
|
for (i = 0; i < avbuf->num_planes; i++) {
|
|
ret = v4l2_buf_to_bufref(avbuf, i, &frame->buf[i]);
|
|
if (ret)
|
|
return ret;
|
|
|
|
frame->linesize[i] = avbuf->plane_info[i].bytesperline;
|
|
frame->data[i] = frame->buf[i]->data;
|
|
}
|
|
|
|
/* fixup special cases */
|
|
switch (avbuf->context->av_pix_fmt) {
|
|
case AV_PIX_FMT_NV12:
|
|
case AV_PIX_FMT_NV21:
|
|
if (avbuf->num_planes > 1)
|
|
break;
|
|
frame->linesize[1] = avbuf->plane_info[0].bytesperline;
|
|
frame->data[1] = frame->buf[0]->data + avbuf->plane_info[0].bytesperline * avbuf->context->format.fmt.pix_mp.height;
|
|
break;
|
|
|
|
case AV_PIX_FMT_YUV420P:
|
|
if (avbuf->num_planes > 1)
|
|
break;
|
|
frame->linesize[1] = avbuf->plane_info[0].bytesperline >> 1;
|
|
frame->linesize[2] = avbuf->plane_info[0].bytesperline >> 1;
|
|
frame->data[1] = frame->buf[0]->data + avbuf->plane_info[0].bytesperline * avbuf->context->format.fmt.pix_mp.height;
|
|
frame->data[2] = frame->data[1] + ((avbuf->plane_info[0].bytesperline * avbuf->context->format.fmt.pix_mp.height) >> 2);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int v4l2_buffer_swframe_to_buf(const AVFrame *frame, V4L2Buffer *out)
|
|
{
|
|
int i, ret;
|
|
struct v4l2_format fmt = out->context->format;
|
|
int pixel_format = V4L2_TYPE_IS_MULTIPLANAR(fmt.type) ?
|
|
fmt.fmt.pix_mp.pixelformat : fmt.fmt.pix.pixelformat;
|
|
int height = V4L2_TYPE_IS_MULTIPLANAR(fmt.type) ?
|
|
fmt.fmt.pix_mp.height : fmt.fmt.pix.height;
|
|
int is_planar_format = 0;
|
|
|
|
switch (pixel_format) {
|
|
case V4L2_PIX_FMT_YUV420M:
|
|
case V4L2_PIX_FMT_YVU420M:
|
|
#ifdef V4L2_PIX_FMT_YUV422M
|
|
case V4L2_PIX_FMT_YUV422M:
|
|
#endif
|
|
#ifdef V4L2_PIX_FMT_YVU422M
|
|
case V4L2_PIX_FMT_YVU422M:
|
|
#endif
|
|
#ifdef V4L2_PIX_FMT_YUV444M
|
|
case V4L2_PIX_FMT_YUV444M:
|
|
#endif
|
|
#ifdef V4L2_PIX_FMT_YVU444M
|
|
case V4L2_PIX_FMT_YVU444M:
|
|
#endif
|
|
case V4L2_PIX_FMT_NV12M:
|
|
case V4L2_PIX_FMT_NV21M:
|
|
case V4L2_PIX_FMT_NV12MT_16X16:
|
|
case V4L2_PIX_FMT_NV12MT:
|
|
case V4L2_PIX_FMT_NV16M:
|
|
case V4L2_PIX_FMT_NV61M:
|
|
is_planar_format = 1;
|
|
}
|
|
|
|
if (!is_planar_format) {
|
|
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
|
|
int planes_nb = 0;
|
|
int offset = 0;
|
|
|
|
for (i = 0; i < desc->nb_components; i++)
|
|
planes_nb = FFMAX(planes_nb, desc->comp[i].plane + 1);
|
|
|
|
for (i = 0; i < planes_nb; i++) {
|
|
int size, h = height;
|
|
if (i == 1 || i == 2) {
|
|
h = AV_CEIL_RSHIFT(h, desc->log2_chroma_h);
|
|
}
|
|
size = frame->linesize[i] * h;
|
|
ret = v4l2_bufref_to_buf(out, 0, frame->data[i], size, offset, frame->buf[i]);
|
|
if (ret)
|
|
return ret;
|
|
offset += size;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
for (i = 0; i < out->num_planes; i++) {
|
|
ret = v4l2_bufref_to_buf(out, i, frame->buf[i]->data, frame->buf[i]->size, 0, frame->buf[i]);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* V4L2Buffer interface
|
|
*
|
|
******************************************************************************/
|
|
|
|
int ff_v4l2_buffer_avframe_to_buf(const AVFrame *frame, V4L2Buffer *out)
|
|
{
|
|
v4l2_set_pts(out, frame->pts);
|
|
|
|
return v4l2_buffer_swframe_to_buf(frame, out);
|
|
}
|
|
|
|
int ff_v4l2_buffer_buf_to_avframe(AVFrame *frame, V4L2Buffer *avbuf)
|
|
{
|
|
int ret;
|
|
|
|
av_frame_unref(frame);
|
|
|
|
/* 1. get references to the actual data */
|
|
ret = v4l2_buffer_buf_to_swframe(frame, avbuf);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* 2. get frame information */
|
|
frame->key_frame = !!(avbuf->buf.flags & V4L2_BUF_FLAG_KEYFRAME);
|
|
frame->color_primaries = v4l2_get_color_primaries(avbuf);
|
|
frame->colorspace = v4l2_get_color_space(avbuf);
|
|
frame->color_range = v4l2_get_color_range(avbuf);
|
|
frame->color_trc = v4l2_get_color_trc(avbuf);
|
|
frame->pts = v4l2_get_pts(avbuf);
|
|
frame->pkt_dts = AV_NOPTS_VALUE;
|
|
|
|
/* these values are updated also during re-init in v4l2_process_driver_event */
|
|
frame->height = avbuf->context->height;
|
|
frame->width = avbuf->context->width;
|
|
frame->sample_aspect_ratio = avbuf->context->sample_aspect_ratio;
|
|
|
|
/* 3. report errors upstream */
|
|
if (avbuf->buf.flags & V4L2_BUF_FLAG_ERROR) {
|
|
av_log(logger(avbuf), AV_LOG_ERROR, "%s: driver decode error\n", avbuf->context->name);
|
|
frame->decode_error_flags |= FF_DECODE_ERROR_INVALID_BITSTREAM;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ff_v4l2_buffer_buf_to_avpkt(AVPacket *pkt, V4L2Buffer *avbuf)
|
|
{
|
|
int ret;
|
|
|
|
av_packet_unref(pkt);
|
|
ret = v4l2_buf_to_bufref(avbuf, 0, &pkt->buf);
|
|
if (ret)
|
|
return ret;
|
|
|
|
pkt->size = V4L2_TYPE_IS_MULTIPLANAR(avbuf->buf.type) ? avbuf->buf.m.planes[0].bytesused : avbuf->buf.bytesused;
|
|
pkt->data = pkt->buf->data;
|
|
|
|
if (avbuf->buf.flags & V4L2_BUF_FLAG_KEYFRAME)
|
|
pkt->flags |= AV_PKT_FLAG_KEY;
|
|
|
|
if (avbuf->buf.flags & V4L2_BUF_FLAG_ERROR) {
|
|
av_log(logger(avbuf), AV_LOG_ERROR, "%s driver encode error\n", avbuf->context->name);
|
|
pkt->flags |= AV_PKT_FLAG_CORRUPT;
|
|
}
|
|
|
|
pkt->dts = pkt->pts = v4l2_get_pts(avbuf);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ff_v4l2_buffer_avpkt_to_buf(const AVPacket *pkt, V4L2Buffer *out)
|
|
{
|
|
int ret;
|
|
|
|
ret = v4l2_bufref_to_buf(out, 0, pkt->data, pkt->size, 0, pkt->buf);
|
|
if (ret)
|
|
return ret;
|
|
|
|
v4l2_set_pts(out, pkt->pts);
|
|
|
|
if (pkt->flags & AV_PKT_FLAG_KEY)
|
|
out->flags = V4L2_BUF_FLAG_KEYFRAME;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ff_v4l2_buffer_initialize(V4L2Buffer* avbuf, int index)
|
|
{
|
|
V4L2Context *ctx = avbuf->context;
|
|
int ret, i;
|
|
|
|
avbuf->buf.memory = V4L2_MEMORY_MMAP;
|
|
avbuf->buf.type = ctx->type;
|
|
avbuf->buf.index = index;
|
|
|
|
if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
|
|
avbuf->buf.length = VIDEO_MAX_PLANES;
|
|
avbuf->buf.m.planes = avbuf->planes;
|
|
}
|
|
|
|
ret = ioctl(buf_to_m2mctx(avbuf)->fd, VIDIOC_QUERYBUF, &avbuf->buf);
|
|
if (ret < 0)
|
|
return AVERROR(errno);
|
|
|
|
if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
|
|
avbuf->num_planes = 0;
|
|
/* in MP, the V4L2 API states that buf.length means num_planes */
|
|
for (i = 0; i < avbuf->buf.length; i++) {
|
|
if (avbuf->buf.m.planes[i].length)
|
|
avbuf->num_planes++;
|
|
}
|
|
} else
|
|
avbuf->num_planes = 1;
|
|
|
|
for (i = 0; i < avbuf->num_planes; i++) {
|
|
|
|
avbuf->plane_info[i].bytesperline = V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ?
|
|
ctx->format.fmt.pix_mp.plane_fmt[i].bytesperline :
|
|
ctx->format.fmt.pix.bytesperline;
|
|
|
|
if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
|
|
avbuf->plane_info[i].length = avbuf->buf.m.planes[i].length;
|
|
avbuf->plane_info[i].mm_addr = mmap(NULL, avbuf->buf.m.planes[i].length,
|
|
PROT_READ | PROT_WRITE, MAP_SHARED,
|
|
buf_to_m2mctx(avbuf)->fd, avbuf->buf.m.planes[i].m.mem_offset);
|
|
} else {
|
|
avbuf->plane_info[i].length = avbuf->buf.length;
|
|
avbuf->plane_info[i].mm_addr = mmap(NULL, avbuf->buf.length,
|
|
PROT_READ | PROT_WRITE, MAP_SHARED,
|
|
buf_to_m2mctx(avbuf)->fd, avbuf->buf.m.offset);
|
|
}
|
|
|
|
if (avbuf->plane_info[i].mm_addr == MAP_FAILED)
|
|
return AVERROR(ENOMEM);
|
|
}
|
|
|
|
avbuf->status = V4L2BUF_AVAILABLE;
|
|
|
|
if (V4L2_TYPE_IS_OUTPUT(ctx->type))
|
|
return 0;
|
|
|
|
if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
|
|
avbuf->buf.m.planes = avbuf->planes;
|
|
avbuf->buf.length = avbuf->num_planes;
|
|
|
|
} else {
|
|
avbuf->buf.bytesused = avbuf->planes[0].bytesused;
|
|
avbuf->buf.length = avbuf->planes[0].length;
|
|
}
|
|
|
|
return ff_v4l2_buffer_enqueue(avbuf);
|
|
}
|
|
|
|
int ff_v4l2_buffer_enqueue(V4L2Buffer* avbuf)
|
|
{
|
|
int ret;
|
|
|
|
avbuf->buf.flags = avbuf->flags;
|
|
|
|
ret = ioctl(buf_to_m2mctx(avbuf)->fd, VIDIOC_QBUF, &avbuf->buf);
|
|
if (ret < 0)
|
|
return AVERROR(errno);
|
|
|
|
avbuf->status = V4L2BUF_IN_DRIVER;
|
|
|
|
return 0;
|
|
}
|