virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-11-21 10:55:51 +02:00
Code Issues Releases Activity
8dc973dc89
FFmpeg/libavcodec/v4l2_buffers.c
Aman Gupta 8dc973dc89 avcodec/v4l2_buffers: read height/width from the proper context 
Frames are generally dequeued into capture buffers, so using
the output properties here was incorrect. It happened to work
fine for decoding, since the output/capture buffers have the same
dimensions.

For the v4l2 scaler, the dimensions can be different between output
and capture. Using the buffer's associated context makes this code
work correctly regardless of where the frame is coming from.

Signed-off-by: Aman Gupta <aman@tmm1.net>
2019-09-11 10:28:56 -07:00

561 lines
17 KiB
C
Raw Blame History

/*
* 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 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 void v4l2_set_pts(V4L2Buffer *out, int64_t pts)
{
V4L2m2mContext *s = buf_to_m2mctx(out);
AVRational v4l2_timebase = { 1, USEC_PER_SEC };
int64_t v4l2_pts;
if (pts == AV_NOPTS_VALUE)
pts = 0;
/* convert pts to v4l2 timebase */
v4l2_pts = av_rescale_q(pts, s->avctx->time_base, 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)
{
V4L2m2mContext *s = buf_to_m2mctx(avbuf);
AVRational v4l2_timebase = { 1, USEC_PER_SEC };
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, s->avctx->time_base);
}
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) {
/* 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:
case V4L2_PIX_FMT_YUV422M:
case V4L2_PIX_FMT_YVU422M:
case V4L2_PIX_FMT_YUV444M:
case V4L2_PIX_FMT_YVU444M:
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);
/* these two values are updated also during re-init in v4l2_process_driver_event */
frame->height = avbuf->context->height;
frame->width = avbuf->context->width;
/* 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;
for (;;) {
/* in MP, the V4L2 API states that buf.length means num_planes */
if (avbuf->num_planes >= avbuf->buf.length)
break;
if (avbuf->buf.m.planes[avbuf->num_planes].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;
}
Reference in New Issue View Git Blame Copy Permalink