util/vpe-common.c

   1 /*
   2  *  Copyright (c) 2013-2014, Texas Instruments Incorporated
   3  *  Author: alaganraj <alaganraj.s@ti.com>
   4  *
   5  *  Redistribution and use in source and binary forms, with or without
   6  *  modification, are permitted provided that the following conditions
   7  *  are met:
   8  *
   9  *  *  Redistributions of source code must retain the above copyright
  10  *     notice, this list of conditions and the following disclaimer.
  11  *
  12  *  *  Redistributions in binary form must reproduce the above copyright
  13  *     notice, this list of conditions and the following disclaimer in the
  14  *     documentation and/or other materials provided with the distribution.
  15  *
  16  *  *  Neither the name of Texas Instruments Incorporated nor the names of
  17  *     its contributors may be used to endorse or promote products derived
  18  *     from this software without specific prior written permission.
  19  *
  20  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  22  *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  24  *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  25  *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  26  *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  27  *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  28  *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  *  Contact information for paper mail:
  33  *  Texas Instruments
  34  *  Post Office Box 655303
  35  *  Dallas, Texas 75265
  36  *  Contact information:
  37  *  http://www-k.ext.ti.com/sc/technical-support/product-information-centers.htm?
  38  *  DCMP=TIHomeTracking&HQS=Other+OT+home_d_contact
  39  *  ============================================================================
  40  *
  41  */
  42
  43 /*
  44  * @File        vpe-common.c
  45  * @Brief       vpe specific common functions, used to integrate vpe
  46  *              with other modules.
  47  *
  48  *              Input buffer must be allocated in application, queue it to vpe
  49  *              by passing buffer index
  50  *
  51  *              Output buffer allocated in vpe_output_init() as vpe output intended
  52  *              to display on LCD.
  53  */
  54 #include <stdio.h>
  55 #include <stdlib.h>
  56 #include <fcntl.h>
  57 #include <unistd.h>
  58 #include <stdint.h>
  59 #include <string.h>
  60 #include <errno.h>
  61
  62 #include <linux/videodev2.h>
  63 #include <linux/v4l2-controls.h>
  64
  65 #include <sys/mman.h>
  66 #include <sys/ioctl.h>
  67
  68 #include <xf86drm.h>
  69 #include <omap_drm.h>
  70 #include <omap_drmif.h>
  71
  72 #include "util.h"
  73
  74 #define pexit(fmt, arg...) { \
  75                 printf(fmt, ## arg); \
  76                 exit(1); \
  77 }
  78
  79 #define V4L2_CID_TRANS_NUM_BUFS         (V4L2_CID_PRIVATE_BASE)
  80 #define NUMBUF                          6
  81
  82 //#define vpe_debug
  83
  84 #ifdef vpe_debug
  85 #define dprintf(fmt, arg...) printf(fmt, ## arg)
  86 #else
  87 #define dprintf(fmt, arg...) do {} while(0)
  88 #endif
  89
  90 struct image_params {
  91         int width;
  92         int height;
  93         int fourcc;
  94         int size;
  95         int size_uv;
  96         int coplanar;
  97         enum v4l2_colorspace colorspace;
  98         int numbuf;
  99 };
 100
 101 struct vpe {
 102         int fd;
 103         int field;
 104         int deint;
 105         int translen;
 106         struct image_params src;
 107         struct image_params dst;
 108         struct  v4l2_crop crop;
 109         int input_buf_dmafd[NUMBUF];
 110         int input_buf_dmafd_uv[NUMBUF];
 111         int output_buf_dmafd[NUMBUF];
 112         int output_buf_dmafd_uv[NUMBUF];
 113         struct display *disp;
 114         struct buffer **disp_bufs;
 115 };
 116
 117 /**
 118  *****************************************************************************
 119  * @brief:  open the device
 120  *
 121  * @return: vpe  struct vpe pointer
 122  *****************************************************************************
 123 */
 124 struct vpe *vpe_open(void)
 125 {
 126         char devname[20] = "/dev/video0";
 127         struct vpe *vpe;
 128
 129         vpe = calloc(1, sizeof(*vpe));
 130
 131         vpe->fd =  open(devname, O_RDWR);
 132         if(vpe->fd < 0)
 133                 pexit("Cant open %s\n", devname);
 134
 135         printf("vpe:%s open success!!!\n", devname);
 136
 137         return vpe;
 138 }
 139
 140 /**
 141  *****************************************************************************
 142  * @brief:  close the device and free memory
 143  *
 144  * @param:  vpe  struct vpe pointer
 145  *
 146  * @return: 0 on success
 147  *****************************************************************************
 148 */
 149 int vpe_close(struct vpe *vpe)
 150 {
 151         close(vpe->fd);
 152         free(vpe);
 153
 154         return 0;
 155 }
 156
 157 /**
 158  *****************************************************************************
 159  * @brief:  fills 4cc, size, coplanar, colorspace based on command line input
 160  *
 161  * @param:  format  char pointer
 162  * @param:  image  struct image_params pointer
 163  *
 164  * @return: 0 on success
 165  *****************************************************************************
 166 */
 167 int describeFormat (char *format, struct image_params *image)
 168 {
 169         image->size   = -1;
 170         image->fourcc = -1;
 171         if (strcmp (format, "rgb24") == 0) {
 172                 image->fourcc = V4L2_PIX_FMT_RGB24;
 173                 image->size = image->height * image->width * 3;
 174                 image->coplanar = 0;
 175                 image->colorspace = V4L2_COLORSPACE_SRGB;
 176
 177         } else if (strcmp (format, "bgr24") == 0) {
 178                 image->fourcc = V4L2_PIX_FMT_BGR24;
 179                 image->size = image->height * image->width * 3;
 180                 image->coplanar = 0;
 181                 image->colorspace = V4L2_COLORSPACE_SRGB;
 182
 183         } else if (strcmp (format, "argb32") == 0) {
 184                 image->fourcc = V4L2_PIX_FMT_RGB32;
 185                 image->size = image->height * image->width * 4;
 186                 image->coplanar = 0;
 187                 image->colorspace = V4L2_COLORSPACE_SRGB;
 188
 189         } else if (strcmp (format, "abgr32") == 0) {
 190                 image->fourcc = V4L2_PIX_FMT_BGR32;
 191                 image->size = image->height * image->width * 4;
 192                 image->coplanar = 0;
 193                 image->colorspace = V4L2_COLORSPACE_SRGB;
 194
 195         } else if (strcmp (format, "yuv444") == 0) {
 196                 image->fourcc = V4L2_PIX_FMT_YUV444;
 197                 image->size = image->height * image->width * 3;
 198                 image->coplanar = 0;
 199                 image->colorspace = V4L2_COLORSPACE_SMPTE170M;
 200
 201         } else if (strcmp (format, "yvyu") == 0) {
 202                 image->fourcc = V4L2_PIX_FMT_YVYU;
 203                 image->size = image->height * image->width * 2;
 204                 image->coplanar = 0;
 205                 image->colorspace = V4L2_COLORSPACE_SMPTE170M;
 206
 207         } else if (strcmp (format, "yuyv") == 0) {
 208                 image->fourcc = V4L2_PIX_FMT_YUYV;
 209                 image->size = image->height * image->width * 2;
 210                 image->coplanar = 0;
 211                 image->colorspace = V4L2_COLORSPACE_SMPTE170M;
 212
 213         } else if (strcmp (format, "uyvy") == 0) {
 214                 image->fourcc = V4L2_PIX_FMT_UYVY;
 215                 image->size = image->height * image->width * 2;
 216                 image->coplanar = 0;
 217                 image->colorspace = V4L2_COLORSPACE_SMPTE170M;
 218
 219         } else if (strcmp (format, "vyuy") == 0) {
 220                 image->fourcc = V4L2_PIX_FMT_VYUY;
 221                 image->size = image->height * image->width * 2;
 222                 image->coplanar = 0;
 223                 image->colorspace = V4L2_COLORSPACE_SMPTE170M;
 224
 225         } else if (strcmp (format, "nv16") == 0) {
 226                 image->fourcc = V4L2_PIX_FMT_NV16;
 227                 image->size = image->height * image->width * 2;
 228                 image->coplanar = 0;
 229                 image->colorspace = V4L2_COLORSPACE_SMPTE170M;
 230
 231         } else if (strcmp (format, "nv61") == 0) {
 232                 image->fourcc = V4L2_PIX_FMT_NV61;
 233                 image->size = image->height * image->width * 2;
 234                 image->coplanar = 0;
 235                 image->colorspace = V4L2_COLORSPACE_SMPTE170M;
 236
 237         } else if (strcmp (format, "nv12") == 0) {
 238                 image->fourcc = V4L2_PIX_FMT_NV12;
 239                 image->size = image->height * image->width * 1.5;
 240                 image->coplanar = 1;
 241                 image->colorspace = V4L2_COLORSPACE_SMPTE170M;
 242
 243         } else if (strcmp (format, "nv21") == 0) {
 244                 image->fourcc = V4L2_PIX_FMT_NV21;
 245                 image->size = image->height * image->width * 1.5;
 246                 image->coplanar = 1;
 247                 image->colorspace = V4L2_COLORSPACE_SMPTE170M;
 248
 249         } else {
 250                 return 0;
 251
 252         }
 253
 254         return 1;
 255 }
 256
 257 /**
 258  *****************************************************************************
 259  * @brief:  sets crop parameters
 260  *
 261  * @param:  vpe  struct vpe pointer
 262  *
 263  * @return: 0 on success
 264  *****************************************************************************
 265 */
 266 static int set_crop(struct vpe *vpe)
 267 {
 268         int ret = 0;
 269
 270         if ((vpe->crop.c.top == 0) && (vpe->crop.c.left == 0) &&
 271             (vpe->crop.c.width == 0) && (vpe->crop.c.height == 0)) {
 272                 dprintf("setting default crop params\n");
 273                 vpe->crop.c.top = 0;
 274                 vpe->crop.c.left = 0;
 275                 vpe->crop.c.width = vpe->src.width;
 276                 vpe->crop.c.height = vpe->src.height;
 277                 vpe->crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
 278         }
 279
 280         ret = ioctl(vpe->fd, VIDIOC_S_CROP, &vpe->crop);
 281         if (ret < 0)
 282                 pexit("error setting crop\n");
 283
 284         return 0;
 285 }
 286
 287 /**
 288  *****************************************************************************
 289  * @brief:  sets control, howmany jobs to be handled on multi instance
 290  *
 291  * @param:  vpe  struct vpe pointer
 292  *
 293  * @return: 0 on success
 294  *****************************************************************************
 295 */
 296 static int set_ctrl(struct vpe *vpe)
 297 {
 298         int ret;
 299         struct  v4l2_control ctrl;
 300
 301         memset(&ctrl, 0, sizeof(ctrl));
 302         ctrl.id = V4L2_CID_TRANS_NUM_BUFS;
 303         ctrl.value = vpe->translen;
 304         ret = ioctl(vpe->fd, VIDIOC_S_CTRL, &ctrl);
 305         if (ret < 0)
 306                 pexit("vpe: S_CTRL failed\n");
 307
 308         return 0;
 309 }
 310
 311 /**
 312  *****************************************************************************
 313  * @brief:  Intialize the vpe input by calling set_control, set_format,
 314  *          set_crop, refbuf ioctls
 315  *
 316  * @param:  vpe  struct vpe pointer
 317  *
 318  * @return: 0 on success
 319  *****************************************************************************
 320 */
 321 int vpe_input_init(struct vpe *vpe)
 322 {
 323         int ret;
 324         struct v4l2_format fmt;
 325         struct v4l2_requestbuffers rqbufs;
 326
 327         set_ctrl(vpe);
 328
 329         memset(&fmt, 0, sizeof fmt);
 330         fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
 331
 332         ret = ioctl(vpe->fd, VIDIOC_G_FMT, &fmt);
 333         if (ret < 0)
 334                 pexit( "vpe i/p: G_FMT_1 failed: %s\n", strerror(errno));
 335
 336         fmt.fmt.pix_mp.width = vpe->src.width;
 337         fmt.fmt.pix_mp.height = vpe->src.height;
 338         fmt.fmt.pix_mp.pixelformat = vpe->src.fourcc;
 339
 340         switch (vpe->deint) {
 341         case 1:
 342                 fmt.fmt.pix_mp.field = V4L2_FIELD_ALTERNATE;
 343                 break;
 344         case 2:
 345                 fmt.fmt.pix_mp.field = V4L2_FIELD_SEQ_TB;
 346                 break;
 347         case 0:
 348         default:
 349                 fmt.fmt.pix_mp.field = V4L2_FIELD_ANY;
 350                 break;
 351         }
 352
 353         ret = ioctl(vpe->fd, VIDIOC_S_FMT, &fmt);
 354         if (ret < 0) {
 355                 pexit( "vpe i/p: S_FMT failed: %s\n", strerror(errno));
 356         } else {
 357                 vpe->src.size = fmt.fmt.pix_mp.plane_fmt[0].sizeimage;
 358                 vpe->src.size_uv = fmt.fmt.pix_mp.plane_fmt[1].sizeimage;
 359         }
 360
 361         ret = ioctl(vpe->fd, VIDIOC_G_FMT, &fmt);
 362         if (ret < 0)
 363                 pexit( "vpe i/p: G_FMT_2 failed: %s\n", strerror(errno));
 364
 365         printf("vpe i/p: G_FMT: width = %u, height = %u, 4cc = %.4s\n",
 366                         fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height,
 367                         (char*)&fmt.fmt.pix_mp.pixelformat);
 368
 369         set_crop(vpe);
 370
 371         memset(&rqbufs, 0, sizeof(rqbufs));
 372         rqbufs.count = NUMBUF;
 373         rqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
 374         rqbufs.memory = V4L2_MEMORY_DMABUF;
 375
 376         ret = ioctl(vpe->fd, VIDIOC_REQBUFS, &rqbufs);
 377         if (ret < 0)
 378                 pexit( "vpe i/p: REQBUFS failed: %s\n", strerror(errno));
 379
 380         vpe->src.numbuf = rqbufs.count;
 381         dprintf("vpe i/p: allocated buffers = %d\n", rqbufs.count);
 382
 383         return 0;
 384
 385 }
 386
 387 /**
 388  *****************************************************************************
 389  * @brief:  Initialize vpe output by calling set_format, reqbuf ioctls.
 390  *          Also allocates buffer to display the vpe output.
 391  *
 392  * @param:  vpe  struct vpe pointer
 393  *
 394  * @return: 0 on success
 395  *****************************************************************************
 396 */
 397 int vpe_output_init(struct vpe *vpe)
 398 {
 399         int ret, i;
 400         struct v4l2_format fmt;
 401         struct v4l2_requestbuffers rqbufs;
 402
 403         memset(&fmt, 0, sizeof fmt);
 404         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
 405
 406         ret = ioctl(vpe->fd, VIDIOC_G_FMT, &fmt);
 407         if (ret < 0)
 408                 pexit( "vpe o/p: G_FMT_1 failed: %s\n", strerror(errno));
 409
 410         fmt.fmt.pix_mp.width = vpe->dst.width;
 411         fmt.fmt.pix_mp.height = vpe->dst.height;
 412         fmt.fmt.pix_mp.pixelformat = vpe->dst.fourcc;
 413         fmt.fmt.pix_mp.field = V4L2_FIELD_ANY;
 414
 415         ret = ioctl(vpe->fd, VIDIOC_S_FMT, &fmt);
 416         if (ret < 0)
 417                 pexit( "vpe o/p: S_FMT failed: %s\n", strerror(errno));
 418
 419         ret = ioctl(vpe->fd, VIDIOC_G_FMT, &fmt);
 420         if (ret < 0)
 421                 pexit( "vpe o/p: G_FMT_2 failed: %s\n", strerror(errno));
 422
 423         printf("vpe o/p: G_FMT: width = %u, height = %u, 4cc = %.4s\n",
 424                         fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height,
 425                         (char*)&fmt.fmt.pix_mp.pixelformat);
 426
 427         memset(&rqbufs, 0, sizeof(rqbufs));
 428         rqbufs.count = NUMBUF;
 429         rqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
 430         rqbufs.memory = V4L2_MEMORY_DMABUF;
 431
 432         ret = ioctl(vpe->fd, VIDIOC_REQBUFS, &rqbufs);
 433         if (ret < 0)
 434                 pexit( "vpe o/p: REQBUFS failed: %s\n", strerror(errno));
 435
 436         vpe->dst.numbuf = rqbufs.count;
 437         dprintf("vpe o/p: allocated buffers = %d\n", rqbufs.count);
 438
 439         vpe->disp_bufs = disp_get_vid_buffers(vpe->disp, NUMBUF, vpe->dst.fourcc,
 440                                               vpe->dst.width, vpe->dst.height);
 441         if (!vpe->disp_bufs)
 442                 pexit("allocating display buffer failed\n");
 443
 444         for (i = 0; i < NUMBUF; i++) {
 445                 vpe->output_buf_dmafd[i] = omap_bo_dmabuf(vpe->disp_bufs[i]->bo[0]);
 446                 vpe->disp_bufs[i]->fd[0] = vpe->output_buf_dmafd[i];
 447
 448                 if(vpe->dst.coplanar) {
 449                         vpe->output_buf_dmafd_uv[i] = omap_bo_dmabuf(vpe->disp_bufs[i]->bo[1]);
 450                         vpe->disp_bufs[i]->fd[1] = vpe->output_buf_dmafd_uv[i];
 451                 }
 452                 /* display only image widthxheight, no full screen */
 453                 vpe->disp_bufs[i]->noScale = true;
 454                 dprintf("vpe->disp_bufs_fd[%d] = %d\n", i, vpe->output_buf_dmafd[i]);
 455         }
 456
 457         dprintf("allocating display buffer success\n");
 458         return 0;
 459 }
 460
 461 /**
 462  *****************************************************************************
 463  * @brief:  queue buffer to vpe input
 464  *
 465  * @param:  vpe  struct vpe pointer
 466  * @param:  index  buffer index to queue
 467  *
 468  * @return: 0 on success
 469  *****************************************************************************
 470 */
 471 int vpe_input_qbuf(struct vpe *vpe, int index)
 472 {
 473         int ret, i;
 474         struct v4l2_buffer buf;
 475         struct v4l2_plane planes[2];
 476
 477         dprintf("vpe input buffer queue\n");
 478
 479         memset(&buf, 0, sizeof buf);
 480         memset(&planes, 0, sizeof planes);
 481
 482         planes[0].length = planes[0].bytesused = vpe->src.size;
 483         if(vpe->src.coplanar)
 484                 planes[1].length = planes[1].bytesused = vpe->src.size_uv;
 485
 486         planes[0].data_offset = planes[1].data_offset = 0;
 487
 488         buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
 489         buf.memory = V4L2_MEMORY_DMABUF;
 490         buf.index = index;
 491         buf.m.planes = &planes;
 492         buf.field = vpe->field;
 493         if(vpe->src.coplanar)
 494                 buf.length = 2;
 495         else
 496                 buf.length = 1;
 497
 498         buf.m.planes[0].m.fd = vpe->input_buf_dmafd[index];
 499         if(vpe->src.coplanar)
 500                 buf.m.planes[1].m.fd = vpe->input_buf_dmafd_uv[index];
 501
 502         ret = ioctl(vpe->fd, VIDIOC_QBUF, &buf);
 503         if (ret < 0)
 504                 pexit( "vpe i/p: QBUF failed: %s, index = %d\n",
 505                         strerror(errno), index);
 506
 507         return 0;
 508 }
 509
 510 /**
 511  *****************************************************************************
 512  * @brief:  queue buffer to vpe output
 513  *
 514  * @param:  vpe  struct vpe pointer
 515  * @param:  index  buffer index to queue
 516  *
 517  * @return: 0 on success
 518  *****************************************************************************
 519 */
 520 int vpe_output_qbuf(struct vpe *vpe, int index)
 521 {
 522         int ret, i;
 523         struct v4l2_buffer buf;
 524         struct v4l2_plane planes[2];
 525
 526         dprintf("vpe output buffer queue\n");
 527
 528         memset(&buf, 0, sizeof buf);
 529         memset(&planes, 0, sizeof planes);
 530
 531         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
 532         buf.memory = V4L2_MEMORY_DMABUF;
 533         buf.index = index;
 534         buf.m.planes = &planes;
 535         if(vpe->dst.coplanar)
 536                 buf.length = 2;
 537         else
 538                 buf.length = 1;
 539
 540         buf.m.planes[0].m.fd = vpe->output_buf_dmafd[index];
 541
 542         if(vpe->dst.coplanar)
 543                 buf.m.planes[1].m.fd = vpe->output_buf_dmafd_uv[index];
 544
 545         ret = ioctl(vpe->fd, VIDIOC_QBUF, &buf);
 546         if (ret < 0)
 547                 pexit( "vpe o/p: QBUF failed: %s, index = %d\n",
 548                         strerror(errno), index);
 549
 550         return 0;
 551 }
 552
 553 /**
 554  *****************************************************************************
 555  * @brief:  start stream
 556  *
 557  * @param:  fd  device fd
 558  * @param:  type  buffer type (CAPTURE or OUTPUT)
 559  *
 560  * @return: 0 on success
 561  *****************************************************************************
 562 */
 563 int stream_ON(int fd, int type)
 564 {
 565         int ret;
 566
 567         ret = ioctl(fd, VIDIOC_STREAMON, &type);
 568         if (ret < 0)
 569                 pexit("STREAMON failed,  %d: %s\n", type, strerror(errno));
 570
 571         dprintf("stream ON: done! fd = %d,  type = %d\n", fd, type);
 572
 573         return 0;
 574 }
 575
 576 /**
 577  *****************************************************************************
 578  * @brief:  stop stream
 579  *
 580  * @param:  fd  device fd
 581  * @param:  type  buffer type (CAPTURE or OUTPUT)
 582  *
 583  * @return: 0 on success
 584  *****************************************************************************
 585 */
 586 int stream_OFF(int fd, int type)
 587 {
 588         int ret;
 589
 590         ret = ioctl(fd, VIDIOC_STREAMOFF, &type);
 591         if (ret < 0)
 592                 pexit("STREAMOFF failed, %d: %s\n", type, strerror(errno));
 593
 594         dprintf("stream OFF: done! fd = %d,  type = %d\n", fd, type);
 595
 596         return 0;
 597 }
 598
 599 /**
 600  *****************************************************************************
 601  * @brief:  dequeue vpe input buffer
 602  *
 603  * @param:  vpe  struct vpe pointer
 604  *
 605  * @return: buf.index index of dequeued buffer
 606  *****************************************************************************
 607 */
 608 int vpe_input_dqbuf(struct vpe *vpe)
 609 {
 610         int ret;
 611         struct v4l2_buffer buf;
 612         struct v4l2_plane planes[2];
 613
 614         dprintf("vpe input dequeue buffer\n");
 615
 616         memset(&buf, 0, sizeof buf);
 617         memset(&planes, 0, sizeof planes);
 618
 619         buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
 620         buf.memory = V4L2_MEMORY_DMABUF;
 621         buf.m.planes = &planes;
 622         if(vpe->src.coplanar)
 623                 buf.length = 2;
 624         else
 625                 buf.length = 1;
 626         ret = ioctl(vpe->fd, VIDIOC_DQBUF, &buf);
 627         if (ret < 0)
 628                 pexit("vpe i/p: DQBUF failed: %s\n", strerror(errno));
 629
 630         dprintf("vpe i/p: DQBUF index = %d\n", buf.index);
 631
 632         return buf.index;
 633 }
 634
 635 /**
 636  *****************************************************************************
 637  * @brief:  dequeue vpe output buffer
 638  *
 639  * @param:  vpe  struct vpe pointer
 640  *
 641  * @return: buf.index index of dequeued buffer
 642  *****************************************************************************
 643 */
 644 int vpe_output_dqbuf(struct vpe *vpe)
 645 {
 646         int ret;
 647         struct v4l2_buffer buf;
 648         struct v4l2_plane planes[2];
 649
 650         dprintf("vpe output dequeue buffer\n");
 651
 652         memset(&buf, 0, sizeof buf);
 653         memset(&planes, 0, sizeof planes);
 654
 655         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
 656         buf.memory = V4L2_MEMORY_DMABUF;
 657         buf.m.planes = &planes;
 658         if(vpe->dst.coplanar)
 659                 buf.length = 2;
 660         else
 661                 buf.length = 1;
 662         ret = ioctl(vpe->fd, VIDIOC_DQBUF, &buf);
 663         if (ret < 0)
 664                 pexit("vpe o/p: DQBUF failed: %s\n", strerror(errno));
 665
 666         dprintf("vpe o/p: DQBUF index = %d\n", buf.index);
 667
 668         return buf.index;
 669 }
 670
 671 /**
 672  *****************************************************************************
 673  * @brief:  buffer retried by index and displays the contents
 674  *
 675  * @param:  vpe  struct vpe pointer
 676  * @param: index index of dequeued output buffer
 677  *
 678  * @return: 0 on success
 679  *****************************************************************************
 680 */
 681 int display_buffer(struct vpe *vpe, int index)
 682 {
 683         int ret;
 684         struct buffer *buf;
 685
 686         buf = vpe->disp_bufs[index];
 687         ret = disp_post_vid_buffer(vpe->disp, buf, 0, 0, vpe->dst.width,
 688                                    vpe->dst.height);
 689         if (ret)
 690                 pexit("disp post vid buf failed\n");
 691
 692         return 0;
 693 }
 694