| /* |
| * 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) |
| { |
| 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); |
| 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); |
| 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); |
| 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; |
| } |