git.sesse.net Git - ffmpeg/blob - libavcodec/v4l2_buffers.c

   1 /*
   2  * V4L2 buffer helper functions.
   3  *
   4  * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
   5  * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
   6  *
   7  * This file is part of FFmpeg.
   8  *
   9  * FFmpeg is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * FFmpeg is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with FFmpeg; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 #include <linux/videodev2.h>
  25 #include <sys/ioctl.h>
  26 #include <sys/mman.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29 #include <poll.h>
  30 #include "libavcodec/avcodec.h"
  31 #include "libavcodec/internal.h"
  32 #include "v4l2_context.h"
  33 #include "v4l2_buffers.h"
  34 #include "v4l2_m2m.h"
  35
  36 #define USEC_PER_SEC 1000000
  37
  38 static inline V4L2m2mContext *buf_to_m2mctx(V4L2Buffer *buf)
  39 {
  40     return V4L2_TYPE_IS_OUTPUT(buf->context->type) ?
  41         container_of(buf->context, V4L2m2mContext, output) :
  42         container_of(buf->context, V4L2m2mContext, capture);
  43 }
  44
  45 static inline AVCodecContext *logger(V4L2Buffer *buf)
  46 {
  47     return buf_to_m2mctx(buf)->avctx;
  48 }
  49
  50 static inline void v4l2_set_pts(V4L2Buffer *out, int64_t pts)
  51 {
  52     V4L2m2mContext *s = buf_to_m2mctx(out);
  53     AVRational v4l2_timebase = { 1, USEC_PER_SEC };
  54     int64_t v4l2_pts;
  55
  56     if (pts == AV_NOPTS_VALUE)
  57         pts = 0;
  58
  59     /* convert pts to v4l2 timebase */
  60     v4l2_pts = av_rescale_q(pts, s->avctx->time_base, v4l2_timebase);
  61     out->buf.timestamp.tv_usec = v4l2_pts % USEC_PER_SEC;
  62     out->buf.timestamp.tv_sec = v4l2_pts / USEC_PER_SEC;
  63 }
  64
  65 static inline uint64_t v4l2_get_pts(V4L2Buffer *avbuf)
  66 {
  67     V4L2m2mContext *s = buf_to_m2mctx(avbuf);
  68     AVRational v4l2_timebase = { 1, USEC_PER_SEC };
  69     int64_t v4l2_pts;
  70
  71     /* convert pts back to encoder timebase */
  72     v4l2_pts = avbuf->buf.timestamp.tv_sec * USEC_PER_SEC + avbuf->buf.timestamp.tv_usec;
  73
  74     return av_rescale_q(v4l2_pts, v4l2_timebase, s->avctx->time_base);
  75 }
  76
  77 static enum AVColorPrimaries v4l2_get_color_primaries(V4L2Buffer *buf)
  78 {
  79     enum v4l2_ycbcr_encoding ycbcr;
  80     enum v4l2_colorspace cs;
  81
  82     cs = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
  83         buf->context->format.fmt.pix_mp.colorspace :
  84         buf->context->format.fmt.pix.colorspace;
  85
  86     ycbcr = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
  87         buf->context->format.fmt.pix_mp.ycbcr_enc:
  88         buf->context->format.fmt.pix.ycbcr_enc;
  89
  90     switch(ycbcr) {
  91     case V4L2_YCBCR_ENC_XV709:
  92     case V4L2_YCBCR_ENC_709: return AVCOL_PRI_BT709;
  93     case V4L2_YCBCR_ENC_XV601:
  94     case V4L2_YCBCR_ENC_601:return AVCOL_PRI_BT470M;
  95     default:
  96         break;
  97     }
  98
  99     switch(cs) {
 100     case V4L2_COLORSPACE_470_SYSTEM_BG: return AVCOL_PRI_BT470BG;
 101     case V4L2_COLORSPACE_SMPTE170M: return AVCOL_PRI_SMPTE170M;
 102     case V4L2_COLORSPACE_SMPTE240M: return AVCOL_PRI_SMPTE240M;
 103     case V4L2_COLORSPACE_BT2020: return AVCOL_PRI_BT2020;
 104     default:
 105         break;
 106     }
 107
 108     return AVCOL_PRI_UNSPECIFIED;
 109 }
 110
 111 static enum AVColorRange v4l2_get_color_range(V4L2Buffer *buf)
 112 {
 113     enum v4l2_quantization qt;
 114
 115     qt = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
 116         buf->context->format.fmt.pix_mp.quantization :
 117         buf->context->format.fmt.pix.quantization;
 118
 119     switch (qt) {
 120     case V4L2_QUANTIZATION_LIM_RANGE: return AVCOL_RANGE_MPEG;
 121     case V4L2_QUANTIZATION_FULL_RANGE: return AVCOL_RANGE_JPEG;
 122     default:
 123         break;
 124     }
 125
 126      return AVCOL_RANGE_UNSPECIFIED;
 127 }
 128
 129 static enum AVColorSpace v4l2_get_color_space(V4L2Buffer *buf)
 130 {
 131     enum v4l2_ycbcr_encoding ycbcr;
 132     enum v4l2_colorspace cs;
 133
 134     cs = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
 135         buf->context->format.fmt.pix_mp.colorspace :
 136         buf->context->format.fmt.pix.colorspace;
 137
 138     ycbcr = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
 139         buf->context->format.fmt.pix_mp.ycbcr_enc:
 140         buf->context->format.fmt.pix.ycbcr_enc;
 141
 142     switch(cs) {
 143     case V4L2_COLORSPACE_SRGB: return AVCOL_SPC_RGB;
 144     case V4L2_COLORSPACE_REC709: return AVCOL_SPC_BT709;
 145     case V4L2_COLORSPACE_470_SYSTEM_M: return AVCOL_SPC_FCC;
 146     case V4L2_COLORSPACE_470_SYSTEM_BG: return AVCOL_SPC_BT470BG;
 147     case V4L2_COLORSPACE_SMPTE170M: return AVCOL_SPC_SMPTE170M;
 148     case V4L2_COLORSPACE_SMPTE240M: return AVCOL_SPC_SMPTE240M;
 149     case V4L2_COLORSPACE_BT2020:
 150         if (ycbcr == V4L2_YCBCR_ENC_BT2020_CONST_LUM)
 151             return AVCOL_SPC_BT2020_CL;
 152         else
 153              return AVCOL_SPC_BT2020_NCL;
 154     default:
 155         break;
 156     }
 157
 158     return AVCOL_SPC_UNSPECIFIED;
 159 }
 160
 161 static enum AVColorTransferCharacteristic v4l2_get_color_trc(V4L2Buffer *buf)
 162 {
 163     enum v4l2_ycbcr_encoding ycbcr;
 164     enum v4l2_xfer_func xfer;
 165     enum v4l2_colorspace cs;
 166
 167     cs = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
 168         buf->context->format.fmt.pix_mp.colorspace :
 169         buf->context->format.fmt.pix.colorspace;
 170
 171     ycbcr = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
 172         buf->context->format.fmt.pix_mp.ycbcr_enc:
 173         buf->context->format.fmt.pix.ycbcr_enc;
 174
 175     xfer = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
 176         buf->context->format.fmt.pix_mp.xfer_func:
 177         buf->context->format.fmt.pix.xfer_func;
 178
 179     switch (xfer) {
 180     case V4L2_XFER_FUNC_709: return AVCOL_TRC_BT709;
 181     case V4L2_XFER_FUNC_SRGB: return AVCOL_TRC_IEC61966_2_1;
 182     default:
 183         break;
 184     }
 185
 186     switch (cs) {
 187     case V4L2_COLORSPACE_470_SYSTEM_M: return AVCOL_TRC_GAMMA22;
 188     case V4L2_COLORSPACE_470_SYSTEM_BG: return AVCOL_TRC_GAMMA28;
 189     case V4L2_COLORSPACE_SMPTE170M: return AVCOL_TRC_SMPTE170M;
 190     case V4L2_COLORSPACE_SMPTE240M: return AVCOL_TRC_SMPTE240M;
 191     default:
 192         break;
 193     }
 194
 195     switch (ycbcr) {
 196     case V4L2_YCBCR_ENC_XV709:
 197     case V4L2_YCBCR_ENC_XV601: return AVCOL_TRC_BT1361_ECG;
 198     default:
 199         break;
 200     }
 201
 202     return AVCOL_TRC_UNSPECIFIED;
 203 }
 204
 205 static void v4l2_free_buffer(void *opaque, uint8_t *unused)
 206 {
 207     V4L2Buffer* avbuf = opaque;
 208     V4L2m2mContext *s = buf_to_m2mctx(avbuf);
 209
 210     atomic_fetch_sub_explicit(&s->refcount, 1, memory_order_acq_rel);
 211     if (s->reinit) {
 212         if (!atomic_load(&s->refcount))
 213             sem_post(&s->refsync);
 214         return;
 215     }
 216
 217     if (avbuf->context->streamon) {
 218         ff_v4l2_buffer_enqueue(avbuf);
 219         return;
 220     }
 221
 222     if (!atomic_load(&s->refcount))
 223         ff_v4l2_m2m_codec_end(s->avctx);
 224 }
 225
 226 static int v4l2_buf_to_bufref(V4L2Buffer *in, int plane, AVBufferRef **buf)
 227 {
 228     V4L2m2mContext *s = buf_to_m2mctx(in);
 229
 230     if (plane >= in->num_planes)
 231         return AVERROR(EINVAL);
 232
 233     /* even though most encoders return 0 in data_offset encoding vp8 does require this value */
 234     *buf = av_buffer_create((char *)in->plane_info[plane].mm_addr + in->planes[plane].data_offset,
 235                             in->plane_info[plane].length, v4l2_free_buffer, in, 0);
 236     if (!*buf)
 237         return AVERROR(ENOMEM);
 238
 239     in->status = V4L2BUF_RET_USER;
 240     atomic_fetch_add_explicit(&s->refcount, 1, memory_order_relaxed);
 241
 242     return 0;
 243 }
 244
 245 static int v4l2_bufref_to_buf(V4L2Buffer *out, int plane, const uint8_t* data, int size, AVBufferRef* bref)
 246 {
 247     if (plane >= out->num_planes)
 248         return AVERROR(EINVAL);
 249
 250     memcpy(out->plane_info[plane].mm_addr, data, FFMIN(size, out->plane_info[plane].length));
 251
 252     out->planes[plane].bytesused = FFMIN(size, out->plane_info[plane].length);
 253     out->planes[plane].length = out->plane_info[plane].length;
 254
 255     return 0;
 256 }
 257
 258 /******************************************************************************
 259  *
 260  *              V4L2uffer interface
 261  *
 262  ******************************************************************************/
 263
 264 int ff_v4l2_buffer_avframe_to_buf(const AVFrame *frame, V4L2Buffer* out)
 265 {
 266     int i, ret;
 267
 268     for(i = 0; i < out->num_planes; i++) {
 269         ret = v4l2_bufref_to_buf(out, i, frame->buf[i]->data, frame->buf[i]->size, frame->buf[i]);
 270         if (ret)
 271             return ret;
 272     }
 273
 274     v4l2_set_pts(out, frame->pts);
 275
 276     return 0;
 277 }
 278
 279 int ff_v4l2_buffer_buf_to_avframe(AVFrame *frame, V4L2Buffer *avbuf)
 280 {
 281     V4L2m2mContext *s = buf_to_m2mctx(avbuf);
 282     int i, ret;
 283
 284     av_frame_unref(frame);
 285
 286     /* 1. get references to the actual data */
 287     for (i = 0; i < avbuf->num_planes; i++) {
 288         ret = v4l2_buf_to_bufref(avbuf, i, &frame->buf[i]);
 289         if (ret)
 290             return ret;
 291
 292         frame->linesize[i] = avbuf->plane_info[i].bytesperline;
 293         frame->data[i] = frame->buf[i]->data;
 294     }
 295
 296     /* 1.1 fixup special cases */
 297     switch (avbuf->context->av_pix_fmt) {
 298     case AV_PIX_FMT_NV12:
 299         if (avbuf->num_planes > 1)
 300             break;
 301         frame->linesize[1] = avbuf->plane_info[0].bytesperline;
 302         frame->data[1] = frame->buf[0]->data + avbuf->plane_info[0].bytesperline * avbuf->context->format.fmt.pix_mp.height;
 303         break;
 304     default:
 305         break;
 306     }
 307
 308     /* 2. get frame information */
 309     frame->key_frame = !!(avbuf->buf.flags & V4L2_BUF_FLAG_KEYFRAME);
 310     frame->format = avbuf->context->av_pix_fmt;
 311     frame->color_primaries = v4l2_get_color_primaries(avbuf);
 312     frame->colorspace = v4l2_get_color_space(avbuf);
 313     frame->color_range = v4l2_get_color_range(avbuf);
 314     frame->color_trc = v4l2_get_color_trc(avbuf);
 315     frame->pts = v4l2_get_pts(avbuf);
 316
 317     /* these two values are updated also during re-init in v4l2_process_driver_event */
 318     frame->height = s->output.height;
 319     frame->width = s->output.width;
 320
 321     /* 3. report errors upstream */
 322     if (avbuf->buf.flags & V4L2_BUF_FLAG_ERROR) {
 323         av_log(logger(avbuf), AV_LOG_ERROR, "%s: driver decode error\n", avbuf->context->name);
 324         frame->decode_error_flags |= FF_DECODE_ERROR_INVALID_BITSTREAM;
 325     }
 326
 327     return 0;
 328 }
 329
 330 int ff_v4l2_buffer_buf_to_avpkt(AVPacket *pkt, V4L2Buffer *avbuf)
 331 {
 332     int ret;
 333
 334     av_packet_unref(pkt);
 335     ret = v4l2_buf_to_bufref(avbuf, 0, &pkt->buf);
 336     if (ret)
 337         return ret;
 338
 339     pkt->size = V4L2_TYPE_IS_MULTIPLANAR(avbuf->buf.type) ? avbuf->buf.m.planes[0].bytesused : avbuf->buf.bytesused;
 340     pkt->data = pkt->buf->data;
 341
 342     if (avbuf->buf.flags & V4L2_BUF_FLAG_KEYFRAME)
 343         pkt->flags |= AV_PKT_FLAG_KEY;
 344
 345     if (avbuf->buf.flags & V4L2_BUF_FLAG_ERROR) {
 346         av_log(logger(avbuf), AV_LOG_ERROR, "%s driver encode error\n", avbuf->context->name);
 347         pkt->flags |= AV_PKT_FLAG_CORRUPT;
 348     }
 349
 350     pkt->dts = pkt->pts = v4l2_get_pts(avbuf);
 351
 352     return 0;
 353 }
 354
 355 int ff_v4l2_buffer_avpkt_to_buf(const AVPacket *pkt, V4L2Buffer *out)
 356 {
 357     int ret;
 358
 359     ret = v4l2_bufref_to_buf(out, 0, pkt->data, pkt->size, pkt->buf);
 360     if (ret)
 361         return ret;
 362
 363     v4l2_set_pts(out, pkt->pts);
 364
 365     if (pkt->flags & AV_PKT_FLAG_KEY)
 366         out->flags = V4L2_BUF_FLAG_KEYFRAME;
 367
 368     return 0;
 369 }
 370
 371 int ff_v4l2_buffer_initialize(V4L2Buffer* avbuf, int index)
 372 {
 373     V4L2Context *ctx = avbuf->context;
 374     int ret, i;
 375
 376     avbuf->buf.memory = V4L2_MEMORY_MMAP;
 377     avbuf->buf.type = ctx->type;
 378     avbuf->buf.index = index;
 379
 380     if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
 381         avbuf->buf.length = VIDEO_MAX_PLANES;
 382         avbuf->buf.m.planes = avbuf->planes;
 383     }
 384
 385     ret = ioctl(buf_to_m2mctx(avbuf)->fd, VIDIOC_QUERYBUF, &avbuf->buf);
 386     if (ret < 0)
 387         return AVERROR(errno);
 388
 389     if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
 390         avbuf->num_planes = 0;
 391         for (;;) {
 392             /* in MP, the V4L2 API states that buf.length means num_planes */
 393             if (avbuf->num_planes >= avbuf->buf.length)
 394                 break;
 395             if (avbuf->buf.m.planes[avbuf->num_planes].length)
 396                 avbuf->num_planes++;
 397         }
 398     } else
 399         avbuf->num_planes = 1;
 400
 401     for (i = 0; i < avbuf->num_planes; i++) {
 402
 403         avbuf->plane_info[i].bytesperline = V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ?
 404             ctx->format.fmt.pix_mp.plane_fmt[i].bytesperline :
 405             ctx->format.fmt.pix.bytesperline;
 406
 407         if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
 408             avbuf->plane_info[i].length = avbuf->buf.m.planes[i].length;
 409             avbuf->plane_info[i].mm_addr = mmap(NULL, avbuf->buf.m.planes[i].length,
 410                                            PROT_READ | PROT_WRITE, MAP_SHARED,
 411                                            buf_to_m2mctx(avbuf)->fd, avbuf->buf.m.planes[i].m.mem_offset);
 412         } else {
 413             avbuf->plane_info[i].length = avbuf->buf.length;
 414             avbuf->plane_info[i].mm_addr = mmap(NULL, avbuf->buf.length,
 415                                           PROT_READ | PROT_WRITE, MAP_SHARED,
 416                                           buf_to_m2mctx(avbuf)->fd, avbuf->buf.m.offset);
 417         }
 418
 419         if (avbuf->plane_info[i].mm_addr == MAP_FAILED)
 420             return AVERROR(ENOMEM);
 421     }
 422
 423     avbuf->status = V4L2BUF_AVAILABLE;
 424
 425     if (V4L2_TYPE_IS_OUTPUT(ctx->type))
 426         return 0;
 427
 428     if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
 429         avbuf->buf.m.planes = avbuf->planes;
 430         avbuf->buf.length   = avbuf->num_planes;
 431
 432     } else {
 433         avbuf->buf.bytesused = avbuf->planes[0].bytesused;
 434         avbuf->buf.length    = avbuf->planes[0].length;
 435     }
 436
 437     return ff_v4l2_buffer_enqueue(avbuf);
 438 }
 439
 440 int ff_v4l2_buffer_enqueue(V4L2Buffer* avbuf)
 441 {
 442     int ret;
 443
 444     avbuf->buf.flags = avbuf->flags;
 445
 446     ret = ioctl(buf_to_m2mctx(avbuf)->fd, VIDIOC_QBUF, &avbuf->buf);
 447     if (ret < 0)
 448         return AVERROR(errno);
 449
 450     avbuf->status = V4L2BUF_IN_DRIVER;
 451
 452     return 0;
 453 }