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     if (atomic_fetch_sub(&avbuf->context_refcount, 1) == 1) {
 211         atomic_fetch_sub_explicit(&s->refcount, 1, memory_order_acq_rel);
 212
 213         if (s->reinit) {
 214             if (!atomic_load(&s->refcount))
 215                 sem_post(&s->refsync);
 216         } else {
 217             if (s->draining) {
 218                 /* no need to queue more buffers to the driver */
 219                 avbuf->status = V4L2BUF_AVAILABLE;
 220             }
 221             else if (avbuf->context->streamon)
 222                 ff_v4l2_buffer_enqueue(avbuf);
 223         }
 224
 225         av_buffer_unref(&avbuf->context_ref);
 226     }
 227 }
 228
 229 static int v4l2_buf_to_bufref(V4L2Buffer *in, int plane, AVBufferRef **buf)
 230 {
 231     V4L2m2mContext *s = buf_to_m2mctx(in);
 232
 233     if (plane >= in->num_planes)
 234         return AVERROR(EINVAL);
 235
 236     /* even though most encoders return 0 in data_offset encoding vp8 does require this value */
 237     *buf = av_buffer_create((char *)in->plane_info[plane].mm_addr + in->planes[plane].data_offset,
 238                             in->plane_info[plane].length, v4l2_free_buffer, in, 0);
 239     if (!*buf)
 240         return AVERROR(ENOMEM);
 241
 242     if (in->context_ref)
 243         atomic_fetch_add(&in->context_refcount, 1);
 244     else {
 245         in->context_ref = av_buffer_ref(s->self_ref);
 246         if (!in->context_ref) {
 247             av_buffer_unref(buf);
 248             return AVERROR(ENOMEM);
 249         }
 250         in->context_refcount = 1;
 251     }
 252
 253     in->status = V4L2BUF_RET_USER;
 254     atomic_fetch_add_explicit(&s->refcount, 1, memory_order_relaxed);
 255
 256     return 0;
 257 }
 258
 259 static int v4l2_bufref_to_buf(V4L2Buffer *out, int plane, const uint8_t* data, int size, AVBufferRef* bref)
 260 {
 261     unsigned int bytesused, length;
 262
 263     if (plane >= out->num_planes)
 264         return AVERROR(EINVAL);
 265
 266     bytesused = FFMIN(size, out->plane_info[plane].length);
 267     length = out->plane_info[plane].length;
 268
 269     memcpy(out->plane_info[plane].mm_addr, data, FFMIN(size, out->plane_info[plane].length));
 270
 271     if (V4L2_TYPE_IS_MULTIPLANAR(out->buf.type)) {
 272         out->planes[plane].bytesused = bytesused;
 273         out->planes[plane].length = length;
 274     } else {
 275         out->buf.bytesused = bytesused;
 276         out->buf.length = length;
 277     }
 278
 279     return 0;
 280 }
 281
 282 /******************************************************************************
 283  *
 284  *              V4L2uffer interface
 285  *
 286  ******************************************************************************/
 287
 288 int ff_v4l2_buffer_avframe_to_buf(const AVFrame *frame, V4L2Buffer* out)
 289 {
 290     int i, ret;
 291
 292     for(i = 0; i < out->num_planes; i++) {
 293         ret = v4l2_bufref_to_buf(out, i, frame->buf[i]->data, frame->buf[i]->size, frame->buf[i]);
 294         if (ret)
 295             return ret;
 296     }
 297
 298     v4l2_set_pts(out, frame->pts);
 299
 300     return 0;
 301 }
 302
 303 int ff_v4l2_buffer_buf_to_avframe(AVFrame *frame, V4L2Buffer *avbuf)
 304 {
 305     V4L2m2mContext *s = buf_to_m2mctx(avbuf);
 306     int i, ret;
 307
 308     av_frame_unref(frame);
 309
 310     /* 1. get references to the actual data */
 311     for (i = 0; i < avbuf->num_planes; i++) {
 312         ret = v4l2_buf_to_bufref(avbuf, i, &frame->buf[i]);
 313         if (ret)
 314             return ret;
 315
 316         frame->linesize[i] = avbuf->plane_info[i].bytesperline;
 317         frame->data[i] = frame->buf[i]->data;
 318     }
 319
 320     /* 1.1 fixup special cases */
 321     switch (avbuf->context->av_pix_fmt) {
 322     case AV_PIX_FMT_NV12:
 323         if (avbuf->num_planes > 1)
 324             break;
 325         frame->linesize[1] = avbuf->plane_info[0].bytesperline;
 326         frame->data[1] = frame->buf[0]->data + avbuf->plane_info[0].bytesperline * avbuf->context->format.fmt.pix_mp.height;
 327         break;
 328     default:
 329         break;
 330     }
 331
 332     /* 2. get frame information */
 333     frame->key_frame = !!(avbuf->buf.flags & V4L2_BUF_FLAG_KEYFRAME);
 334     frame->format = avbuf->context->av_pix_fmt;
 335     frame->color_primaries = v4l2_get_color_primaries(avbuf);
 336     frame->colorspace = v4l2_get_color_space(avbuf);
 337     frame->color_range = v4l2_get_color_range(avbuf);
 338     frame->color_trc = v4l2_get_color_trc(avbuf);
 339     frame->pts = v4l2_get_pts(avbuf);
 340
 341     /* these two values are updated also during re-init in v4l2_process_driver_event */
 342     frame->height = s->output.height;
 343     frame->width = s->output.width;
 344
 345     /* 3. report errors upstream */
 346     if (avbuf->buf.flags & V4L2_BUF_FLAG_ERROR) {
 347         av_log(logger(avbuf), AV_LOG_ERROR, "%s: driver decode error\n", avbuf->context->name);
 348         frame->decode_error_flags |= FF_DECODE_ERROR_INVALID_BITSTREAM;
 349     }
 350
 351     return 0;
 352 }
 353
 354 int ff_v4l2_buffer_buf_to_avpkt(AVPacket *pkt, V4L2Buffer *avbuf)
 355 {
 356     int ret;
 357
 358     av_packet_unref(pkt);
 359     ret = v4l2_buf_to_bufref(avbuf, 0, &pkt->buf);
 360     if (ret)
 361         return ret;
 362
 363     pkt->size = V4L2_TYPE_IS_MULTIPLANAR(avbuf->buf.type) ? avbuf->buf.m.planes[0].bytesused : avbuf->buf.bytesused;
 364     pkt->data = pkt->buf->data;
 365
 366     if (avbuf->buf.flags & V4L2_BUF_FLAG_KEYFRAME)
 367         pkt->flags |= AV_PKT_FLAG_KEY;
 368
 369     if (avbuf->buf.flags & V4L2_BUF_FLAG_ERROR) {
 370         av_log(logger(avbuf), AV_LOG_ERROR, "%s driver encode error\n", avbuf->context->name);
 371         pkt->flags |= AV_PKT_FLAG_CORRUPT;
 372     }
 373
 374     pkt->dts = pkt->pts = v4l2_get_pts(avbuf);
 375
 376     return 0;
 377 }
 378
 379 int ff_v4l2_buffer_avpkt_to_buf(const AVPacket *pkt, V4L2Buffer *out)
 380 {
 381     int ret;
 382
 383     ret = v4l2_bufref_to_buf(out, 0, pkt->data, pkt->size, pkt->buf);
 384     if (ret)
 385         return ret;
 386
 387     v4l2_set_pts(out, pkt->pts);
 388
 389     if (pkt->flags & AV_PKT_FLAG_KEY)
 390         out->flags = V4L2_BUF_FLAG_KEYFRAME;
 391
 392     return 0;
 393 }
 394
 395 int ff_v4l2_buffer_initialize(V4L2Buffer* avbuf, int index)
 396 {
 397     V4L2Context *ctx = avbuf->context;
 398     int ret, i;
 399
 400     avbuf->buf.memory = V4L2_MEMORY_MMAP;
 401     avbuf->buf.type = ctx->type;
 402     avbuf->buf.index = index;
 403
 404     if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
 405         avbuf->buf.length = VIDEO_MAX_PLANES;
 406         avbuf->buf.m.planes = avbuf->planes;
 407     }
 408
 409     ret = ioctl(buf_to_m2mctx(avbuf)->fd, VIDIOC_QUERYBUF, &avbuf->buf);
 410     if (ret < 0)
 411         return AVERROR(errno);
 412
 413     if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
 414         avbuf->num_planes = 0;
 415         for (;;) {
 416             /* in MP, the V4L2 API states that buf.length means num_planes */
 417             if (avbuf->num_planes >= avbuf->buf.length)
 418                 break;
 419             if (avbuf->buf.m.planes[avbuf->num_planes].length)
 420                 avbuf->num_planes++;
 421         }
 422     } else
 423         avbuf->num_planes = 1;
 424
 425     for (i = 0; i < avbuf->num_planes; i++) {
 426
 427         avbuf->plane_info[i].bytesperline = V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ?
 428             ctx->format.fmt.pix_mp.plane_fmt[i].bytesperline :
 429             ctx->format.fmt.pix.bytesperline;
 430
 431         if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
 432             avbuf->plane_info[i].length = avbuf->buf.m.planes[i].length;
 433             avbuf->plane_info[i].mm_addr = mmap(NULL, avbuf->buf.m.planes[i].length,
 434                                            PROT_READ | PROT_WRITE, MAP_SHARED,
 435                                            buf_to_m2mctx(avbuf)->fd, avbuf->buf.m.planes[i].m.mem_offset);
 436         } else {
 437             avbuf->plane_info[i].length = avbuf->buf.length;
 438             avbuf->plane_info[i].mm_addr = mmap(NULL, avbuf->buf.length,
 439                                           PROT_READ | PROT_WRITE, MAP_SHARED,
 440                                           buf_to_m2mctx(avbuf)->fd, avbuf->buf.m.offset);
 441         }
 442
 443         if (avbuf->plane_info[i].mm_addr == MAP_FAILED)
 444             return AVERROR(ENOMEM);
 445     }
 446
 447     avbuf->status = V4L2BUF_AVAILABLE;
 448
 449     if (V4L2_TYPE_IS_OUTPUT(ctx->type))
 450         return 0;
 451
 452     if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
 453         avbuf->buf.m.planes = avbuf->planes;
 454         avbuf->buf.length   = avbuf->num_planes;
 455
 456     } else {
 457         avbuf->buf.bytesused = avbuf->planes[0].bytesused;
 458         avbuf->buf.length    = avbuf->planes[0].length;
 459     }
 460
 461     return ff_v4l2_buffer_enqueue(avbuf);
 462 }
 463
 464 int ff_v4l2_buffer_enqueue(V4L2Buffer* avbuf)
 465 {
 466     int ret;
 467
 468     avbuf->buf.flags = avbuf->flags;
 469
 470     ret = ioctl(buf_to_m2mctx(avbuf)->fd, VIDIOC_QBUF, &avbuf->buf);
 471     if (ret < 0)
 472         return AVERROR(errno);
 473
 474     avbuf->status = V4L2BUF_IN_DRIVER;
 475
 476     return 0;
 477 }