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