From a3f0e09379759e4cfb79e1d5c7d7ac752728fe5f Mon Sep 17 00:00:00 2001
From: Uros Majstorovic <majstor@majstor.org>
Date: Tue, 22 Aug 2017 05:46:13 +0200
Subject: added video test

---
 code/test/vid/Makefile |  17 ++
 code/test/vid/cap.c    | 568 +++++++++++++++++++++++++++++++++++++++++++++++++
 code/test/vid/cap.sh   |   3 +
 code/test/vid/enc.c    | 239 +++++++++++++++++++++
 code/test/vid/enc.h    |  10 +
 code/test/vid/tools.c  |  54 +++++
 code/test/vid/tools.h  |  29 +++
 7 files changed, 920 insertions(+)
 create mode 100644 code/test/vid/Makefile
 create mode 100644 code/test/vid/cap.c
 create mode 100755 code/test/vid/cap.sh
 create mode 100644 code/test/vid/enc.c
 create mode 100644 code/test/vid/enc.h
 create mode 100644 code/test/vid/tools.c
 create mode 100644 code/test/vid/tools.h

(limited to 'code/test')

diff --git a/code/test/vid/Makefile b/code/test/vid/Makefile
new file mode 100644
index 0000000..757429d
--- /dev/null
+++ b/code/test/vid/Makefile
@@ -0,0 +1,17 @@
+LIBVPX_HOME=../libvpx
+CFLAGS=-D_V4L2_KERNEL_ -I/usr/src/linux-headers-$(uname -r) -I$(LIBVPX_HOME)
+LDFLAGS=-L$(LIBVPX_HOME)
+deps=$(LIBVPX_HOME)/ivfenc.c.o $(LIBVPX_HOME)/video_writer.c.o
+
+all: cap
+
+%.o: %.c
+	$(CC) $(CFLAGS) -c $<
+
+cap: cap.o enc.o tools.o
+	$(CC) -o $@ $< enc.o tools.o $(deps) -lvpx -lm -pthread $(LDFLAGS)
+	
+clean:
+	rm -f *.o
+	rm -f cap
+
diff --git a/code/test/vid/cap.c b/code/test/vid/cap.c
new file mode 100644
index 0000000..c156fab
--- /dev/null
+++ b/code/test/vid/cap.c
@@ -0,0 +1,568 @@
+/*
+ *  OpenCV BSD3 License
+ *  videodev2.h BSD License (dual license)
+ *  If you raise some license issue here simply don't use it and let us know
+ * 
+ *  Copyright (C) 2016 the contributors
+ *
+ *  Luiz Vitor Martinez Cardoso
+ *  Jules Thuillier
+ *  @lex (avafinger)
+ *
+ *  gcc cap.c -o cap $(pkg-config --libs --cflags opencv) -lm
+ *
+ *  gcc -I/usr/src/linux-headers-VERSION/ cap.c -o cap $(pkg-config --libs --cflags opencv) -lm -O3
+ *
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <malloc.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+
+/* -----------------------------------------------------------------------------
+ * BananaPi M64 / Pine64+ (A64) or if you want to control Exposure,Hflip,Vflip
+ * -----------------------------------------------------------------------------
+ * _V4L2_KERNEL_ should be defined and point to: /usr/src/linux-headers-version
+ * 
+ * build with: gcc -I/usr/src/linux-headers-3.10.102/ cap.c -o cap $(pkg-config --libs --cflags opencv) -lm -O3
+ *
+ * 
+ * -----------------------------------------------------------------------------
+ * OrangePi / BananaPi / NanoPi (H3) / BPI-M3 (A83T - ov5640 & ov8865)
+ * -----------------------------------------------------------------------------
+ * _V4L2_KERNEL_ should not be defined unless you want Exposure, Hflip and Vflip
+ *
+ * build with: gcc cap.c -o cap $(pkg-config --libs --cflags opencv) -lm
+ *
+ * 
+*/
+//#define _V4L2_KERNEL_	// BananaPi M64 / Pine64+ only or for setting Exposure,Hflip,Vflip
+
+#ifdef _V4L2_KERNEL_
+/* --- A64 --- */
+#include <linux/videodev2.h>
+#else
+/* --- H3 / A83T --- */
+#include "videodev2.h"
+#endif
+
+#ifdef _V4L2_KERNEL_
+#define V4L2_MODE_VIDEO				0x0002  /* video capture */
+#define V4L2_MODE_IMAGE				0x0003  /* image capture */
+#define V4L2_MODE_PREVIEW			0x0004  /* preview capture */
+#endif
+
+#define N_BUFFERS 4
+#define CAP_OK 0
+#define CAP_ERROR -1
+#define CAP_ERROR_RET(s) { \
+							printf("v4l2: %s\n", s); \
+							return CAP_ERROR; \
+						 }
+#define CAP_CLIP(val, min, max) (((val) > (max)) ? (max) : (((val) < (min)) ? (min) : (val)))
+
+#define CLEAR(x) memset (&(x), 0, sizeof (x))
+#define ALIGN_4K(x) (((x) + (4095)) & ~(4095))
+#define ALIGN_16B(x) (((x) + (15)) & ~(15))
+
+#include "enc.h"
+
+typedef struct {
+    void *start;
+    size_t length;
+} v4l2_buffer_t;
+
+int width;
+int height;
+v4l2_buffer_t *buffers = NULL;
+int n_buffers = N_BUFFERS;
+int sensor_video_mode;
+int sensor_exposure;
+int sensor_hflip;
+int sensor_vflip;
+
+double get_wall_time()
+{
+    struct timeval time;
+    if (gettimeofday(&time, NULL))
+        return 0.;
+    return (double) time.tv_sec + (double) time.tv_usec * .000001;
+}
+
+int yuv420p_to_bgr(void *in, int length, unsigned char *out)
+{
+    uint8_t *yptr, *uptr, *vptr;
+    uint32_t x, y, p;
+
+    if (length < (width * height * 3) / 2)
+        return CAP_ERROR;
+
+    yptr = (uint8_t *) in;
+    uptr = yptr + (width * height);
+    vptr = uptr + (width * height / 4);
+    p = 0;
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            int r, g, b;
+            int y, u, v;
+
+            y = *(yptr++) << 8;
+            u = uptr[p] - 128;
+            v = vptr[p] - 128;
+
+            r = (y + (359 * v)) >> 8;
+            g = (y - (88 * u) - (183 * v)) >> 8;
+            b = (y + (454 * u)) >> 8;
+
+            *(out++) += CAP_CLIP(b, 0x00, 0xFF);
+            *(out++) += CAP_CLIP(g, 0x00, 0xFF);
+            *(out++) += CAP_CLIP(r, 0x00, 0xFF);
+
+            if (x & 1)
+                p++;
+        }
+
+        if (!(y & 1))
+            p -= width / 2;
+    }
+
+    return CAP_ERROR;
+}
+
+static int xioctl(int fd, int request, void *arg)
+{
+    int r;
+    int tries = 3;
+
+    do {
+        r = ioctl(fd, request, arg);
+    } while (--tries > 0 && -1 == r && EINTR == errno);
+
+    return r;
+}
+
+int v4l2_display_sizes_pix_format(int fd)
+{
+    int ret = 0;
+    int fsizeind = 0; /*index for supported sizes*/
+    struct v4l2_frmsizeenum fsize;
+
+    printf("V4L2 pixel sizes:\n");
+
+    CLEAR(fsize);
+    fsize.index = 0;
+    fsize.pixel_format = V4L2_PIX_FMT_YUV420;
+
+    while ((ret = xioctl(fd, VIDIOC_ENUM_FRAMESIZES, &fsize)) == 0) {
+        fsize.index++;
+        if (fsize.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
+            printf("( %u x %u ) Pixels\n", fsize.discrete.width, fsize.discrete.height);
+	    fsizeind++;
+        }
+    }
+    return fsizeind;
+}
+
+int v4l2_display_pix_format(int fd)
+{
+    struct v4l2_fmtdesc fmt;
+    int index;
+
+    printf("V4L2 pixel formats:\n");
+
+    index = 0;
+    CLEAR(fmt);
+    fmt.index = index;
+    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+    while (ioctl(fd, VIDIOC_ENUM_FMT, &fmt) != -1) {
+        printf("%i: [0x%08X] '%c%c%c%c' (%s)\n", index, fmt.pixelformat, fmt.pixelformat >> 0, fmt.pixelformat >> 8, fmt.pixelformat >> 16, fmt.pixelformat >> 24, fmt.description);
+
+        memset(&fmt, 0, sizeof(fmt));
+        fmt.index = ++index;
+        fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    }
+    // printf("\n");
+}
+
+#ifdef _V4L2_KERNEL_
+int v4l2_set_exposure(int fd, int exposure)
+{
+    struct v4l2_queryctrl queryctrl;
+    struct v4l2_control control;
+    int rc;
+
+    printf("set Exposure: %d\n", exposure);
+    rc = 0;
+    memset(&control, 0, sizeof(control));
+    control.id = V4L2_CID_EXPOSURE;
+    rc = xioctl(fd, VIDIOC_G_CTRL, &control);
+    printf("rc: %d - get exposure: %d\n", rc, control.value);
+    control.value = exposure;
+    rc = xioctl(fd, VIDIOC_S_CTRL, &control);
+    printf("rc: %d - new exposure: %d\n", rc, exposure);
+    return rc;
+}
+
+int v4l2_set_hflip(int fd, int hflip)
+{
+    struct v4l2_queryctrl queryctrl;
+    struct v4l2_control control;
+    int rc;
+
+    printf("set Hflip: %d\n", hflip);
+    rc = 0;
+    memset(&control, 0, sizeof(control));
+    control.id = V4L2_CID_HFLIP;
+    rc = xioctl(fd, VIDIOC_G_CTRL, &control);
+    printf("rc: %d - get value: %d\n", rc, control.value);
+    control.value = hflip;
+    rc = xioctl(fd, VIDIOC_S_CTRL, &control);
+    printf("rc: %d - new value: %d\n", rc, control.value);
+    return rc;
+}
+
+int v4l2_set_vflip(int fd, int vflip)
+{
+    struct v4l2_queryctrl queryctrl;
+    struct v4l2_control control;
+    int rc;
+
+    printf("set Vflip: %d\n", vflip);
+    rc = 0;
+    memset(&control, 0, sizeof(control));
+    control.id = V4L2_CID_VFLIP;
+    rc = xioctl(fd, VIDIOC_G_CTRL, &control);
+    printf("rc: %d - get value: %d\n", rc, control.value);
+    control.value = vflip;
+    rc = xioctl(fd, VIDIOC_S_CTRL, &control);
+    printf("rc: %d - new value: %d\n", rc, control.value);
+    return rc;
+}
+#endif
+
+int v4l2_init_camera(int fd)
+{
+    uint32_t i;
+    uint32_t index;
+    struct v4l2_streamparm parms;
+    struct v4l2_format fmt;
+    struct v4l2_input input;
+    struct v4l2_capability caps;
+
+    CLEAR(fmt);
+    CLEAR(input);
+    CLEAR(caps);
+
+
+    if (xioctl(fd, VIDIOC_QUERYCAP, &caps) == -1) {
+        CAP_ERROR_RET("unable to query capabilities.");
+    }
+
+    if (!(caps.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
+        CAP_ERROR_RET("doesn't support video capturing.");
+    }
+
+    printf("Driver: \"%s\"\n", caps.driver);
+    printf("Card: \"%s\"\n", caps.card);
+    printf("Bus: \"%s\"\n", caps.bus_info);
+    printf("Version: %d.%d\n", (caps.version >> 16) && 0xff, (caps.version >> 24) && 0xff);
+    printf("Capabilities: %08x\n", caps.capabilities);
+
+    input.index = 0;
+    if (xioctl(fd, VIDIOC_ENUMINPUT, &input) == -1) {
+        CAP_ERROR_RET("unable to enumerate input.");
+    }
+
+    printf("Input: %d\n", input.index);
+    if (xioctl(fd, VIDIOC_S_INPUT, &input.index) == -1) {
+        CAP_ERROR_RET("unable to set input.");
+    }
+
+    parms.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    parms.parm.capture.capturemode = sensor_video_mode ? V4L2_MODE_VIDEO : V4L2_MODE_IMAGE;
+    parms.parm.capture.timeperframe.numerator = 1;
+    parms.parm.capture.timeperframe.denominator = sensor_video_mode ? 30 : 7;
+    if (-1 == xioctl(fd, VIDIOC_S_PARM, &parms)) {
+        CAP_ERROR_RET("unable to set stream parm.");
+    }
+
+    v4l2_display_pix_format(fd);
+    v4l2_display_sizes_pix_format(fd);
+    printf("\n");
+
+    fmt.fmt.pix.width = width;
+    fmt.fmt.pix.height = height;
+    fmt.fmt.pix.field = V4L2_FIELD_NONE;        // V4L2_FIELD_ANY;
+    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
+    //fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB24;
+
+    if (xioctl(fd, VIDIOC_TRY_FMT, &fmt) == -1) {
+        CAP_ERROR_RET("failed trying to set pixel format.");
+    }
+
+    if (fmt.fmt.pix.width != width || fmt.fmt.pix.height != height) {
+        width = fmt.fmt.pix.width;
+        height = fmt.fmt.pix.height;
+        printf("Sensor size adjusted to: %dx%d pixels\n", width, height);
+    } else {
+        printf("Sensor size: %dx%d pixels\n", width, height);
+    }
+
+    if (xioctl(fd, VIDIOC_S_FMT, &fmt) == -1) {
+        CAP_ERROR_RET("failed to set pixel format.");
+    }
+
+    switch (fmt.fmt.pix.pixelformat) {
+    case V4L2_PIX_FMT_RGB24:
+            printf("Pixel Format: V4L2_PIX_FMT_RGB24 [0x%08X]\n",fmt.fmt.pix.pixelformat);
+            break;
+        
+    case V4L2_PIX_FMT_YUV420:
+            printf("Pixel Format: V4L2_PIX_FMT_YUV420 [0x%08X]\n",fmt.fmt.pix.pixelformat);
+            break;
+        
+    }
+
+    return CAP_OK;
+}
+
+int v4l2_set_mmap(int fd, int *buffers_count)
+{
+    int i;
+    int nbf;
+    enum v4l2_buf_type type;
+    struct v4l2_requestbuffers req;
+    struct v4l2_buffer buf;
+
+    CLEAR(req);
+    req.count = sensor_video_mode ? n_buffers : 1;
+    req.memory = V4L2_MEMORY_MMAP;
+    req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    if (xioctl(fd, VIDIOC_REQBUFS, &req) == -1) {
+        CAP_ERROR_RET("failed requesting buffers.");
+    }
+    nbf = req.count;
+    if (n_buffers != nbf) {
+        CAP_ERROR_RET("insufficient buffer memory.");
+    }
+
+    buffers = (v4l2_buffer_t *) calloc(nbf, sizeof(v4l2_buffer_t));
+    if (!buffers) {
+        CAP_ERROR_RET("failed to allocated buffers memory.");
+    }
+
+    for (i = 0; i < nbf; i++) {
+        CLEAR(buf);
+        buf.index = i;
+        buf.memory = V4L2_MEMORY_MMAP;
+        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        if (xioctl(fd, VIDIOC_QUERYBUF, &buf) == -1) {
+            CAP_ERROR_RET("failed to query buffer.");
+        }
+        buffers[i].length = buf.length;
+        buffers[i].start = mmap(NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.offset);
+        if (MAP_FAILED == buffers[i].start) {
+            CAP_ERROR_RET("failed to mmap buffer.");
+        }
+    }
+
+    for (i = 0; i < nbf; i++) {
+        CLEAR(buf);
+        buf.index = i;
+        buf.memory = V4L2_MEMORY_MMAP;
+        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+        if (xioctl(fd, VIDIOC_QBUF, &buf) == -1) {
+            CAP_ERROR_RET("failed to queue buffer.");
+        }
+    }
+
+    type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    if (xioctl(fd, VIDIOC_STREAMON, &type) == -1) {
+        CAP_ERROR_RET("failed to stream on.");
+    }
+
+    *buffers_count = nbf;
+
+    return CAP_OK;
+}
+
+int v4l2_retrieve_frame(int fd, int buffers_count, vpx_image_t *raw, vpx_codec_ctx_t *codec, int frame_count, int kframe_interval)
+{
+    int sz;
+    fd_set fds;
+    unsigned char *frame_yuv;
+    struct timeval tv;
+    struct v4l2_buffer buf;
+    int rc;
+    char err_msg[128];
+    int flags = 0;
+
+    CLEAR(tv);
+    CLEAR(buf);
+
+    rc = 1;
+    while (rc > 0) {
+        FD_ZERO(&fds);
+        FD_SET(fd, &fds);
+
+        tv.tv_sec = 2;
+        tv.tv_usec = 0;
+
+        rc = select(fd + 1, &fds, NULL, NULL, &tv);
+        if (-1 == rc) {
+            if (EINTR == errno) {
+                rc = 1;         // try again
+                continue;
+            }
+            CAP_ERROR_RET("failed to select frame.");
+        }
+        /* we got something */
+        break;
+    }
+    if (rc <= 0) {
+        sprintf(err_msg, "errno: %d - check sensor, something wrong.", errno);
+        CAP_ERROR_RET(err_msg);
+    }
+
+    buf.memory = V4L2_MEMORY_MMAP;
+    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    if (xioctl(fd, VIDIOC_DQBUF, &buf) == -1) {
+        CAP_ERROR_RET("failed to retrieve frame.");
+    }
+
+    // printf("Length: %d \tBytesused: %d \tAddress: %p\n", buf.length, buf.bytesused, &buffers[buf.index]);
+
+    sz = ALIGN_16B(width) * height * 3 / 2;
+    vpx_img_read(raw, buffers[buf.index].start, sz);
+    if (frame_count % kframe_interval == 0)
+      flags |= VPX_EFLAG_FORCE_KF;
+    vpx_encode_frame(codec, raw, frame_count, flags);
+
+    if (xioctl(fd, VIDIOC_QBUF, &buf) == -1) {
+        CAP_ERROR_RET("failed to queue buffer.");
+    }
+
+    return CAP_OK;
+}
+
+int v4l2_close_camera(int fd, int buffers_count)
+{
+    int i;
+    enum v4l2_buf_type type;
+
+    type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    if (xioctl(fd, VIDIOC_STREAMOFF, &type) == -1) {
+        CAP_ERROR_RET("failed to stream off.");
+    }
+
+    for (i = 0; i < buffers_count; i++)
+        munmap(buffers[i].start, buffers[i].length);
+
+    close(fd);
+}
+
+int main(int argc, char *argv[])
+{
+    int i, n;
+    int fd;
+    int target_bitrate = 200;
+    double after;
+    double before;
+    double avg, fps;
+    int buffers_count;
+    int kframe_interval;
+    vpx_codec_er_flags_t err_resilient;
+    int frame_count;
+    char *out_fname;
+
+    if (argc != 13) {
+        CAP_ERROR_RET("./cap <width> <height> <buffers [4,8]> <video mode [0,1]> <exposure [-4,4]> <hflip [0,1]> <vflip [0,1]> <kframe interval> <bitrate> <err resilient> <num frames> <file name>")
+    }
+    n = 0;
+    width = (int) atoi(argv[1]);
+    height = (int) atoi(argv[2]);
+    n_buffers = (int) atoi(argv[3]);
+    if (n_buffers < 4)
+        n_buffers = 4;
+    if (n_buffers > 8)
+        n_buffers = 8;          // enough in VIDEO MODE!!!
+
+    sensor_video_mode = (int) atoi(argv[4]);
+    if (!sensor_video_mode)
+        n_buffers = 1;
+    sensor_exposure = (int) atoi(argv[5]);
+    sensor_hflip = (int) atoi(argv[6]);
+    sensor_vflip = (int) atoi(argv[7]);
+    kframe_interval = (int) atoi(argv[8]);
+    target_bitrate = (int) atoi(argv[9]);
+    err_resilient = strtoul(argv[10], NULL, 0);
+    frame_count = (int) atoi(argv[11]);
+    out_fname = argv[12];
+
+    printf("---- cap parameters -----\nwidth: %d\nheight: %d\nv4l2 buffers: %d\nexposure: %d\nhflip: %d\nvflip: %d\nMode: %s\n", width, height, n_buffers, sensor_exposure, sensor_hflip, sensor_vflip, sensor_video_mode ? "V4L2_MODE_VIDEO" : "V4L2_MODE_IMAGE");
+
+    fd = open("/dev/video0", O_RDWR | O_NONBLOCK);
+    if (fd == -1) {
+        CAP_ERROR_RET("failed to open the camera.");
+    }
+
+    if (v4l2_init_camera(fd) == -1) {
+        CAP_ERROR_RET("failed to init camera.");
+    }
+#ifdef _V4L2_KERNEL_
+    if (sensor_exposure != -999) {
+        v4l2_set_exposure(fd, sensor_exposure);
+    }
+    if (sensor_hflip != -1) {
+        v4l2_set_hflip(fd, sensor_hflip);
+    }
+
+    if (sensor_vflip != -1) {
+        v4l2_set_vflip(fd, sensor_vflip);
+    }
+#endif
+
+    if (v4l2_set_mmap(fd, &buffers_count) == -1) {
+        CAP_ERROR_RET("failed to mmap.");
+    }
+
+    int _fps = 30;
+    const char *codec_arg = "vp9";
+    vpx_codec_ctx_t codec;
+    vpx_image_t raw;
+    vpx_init(codec_arg, out_fname, width, height, _fps);
+    vpx_open(&codec, get_vpx_encoder_by_name(codec_arg)->codec_interface(), width, height, _fps, target_bitrate, err_resilient, &raw);
+
+    for (i = 0; i < frame_count; i++) {
+        before = get_wall_time();
+        if (v4l2_retrieve_frame(fd, buffers_count, &raw, &codec, i, kframe_interval)) {
+            CAP_ERROR_RET("failed to retrieve frame.");
+        }
+        after = get_wall_time();
+        fps = 1.0 / (after - before);
+        avg += fps;
+        n++;
+        // printf("FPS[%d]: %.2f\n", i, fps);
+    }
+
+    vpx_close(&codec, &raw);
+    v4l2_close_camera(fd, buffers_count);
+    
+    if (n) {
+        printf("\n------- Avg FPS: %.2f --------\n\n", (double) (avg / (double) n));
+    }
+
+    return CAP_OK;
+}
diff --git a/code/test/vid/cap.sh b/code/test/vid/cap.sh
new file mode 100755
index 0000000..3dd26a1
--- /dev/null
+++ b/code/test/vid/cap.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+./cap 640 480 8 1 -999 -1 -1 25 256 0 300 capture.ivf
diff --git a/code/test/vid/enc.c b/code/test/vid/enc.c
new file mode 100644
index 0000000..a1730b4
--- /dev/null
+++ b/code/test/vid/enc.c
@@ -0,0 +1,239 @@
+/*
+ *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+// Simple Encoder
+// ==============
+//
+// This is an example of a simple encoder loop. It takes an input file in
+// YV12 format, passes it through the encoder, and writes the compressed
+// frames to disk in IVF format. Other decoder examples build upon this
+// one.
+//
+// The details of the IVF format have been elided from this example for
+// simplicity of presentation, as IVF files will not generally be used by
+// your application. In general, an IVF file consists of a file header,
+// followed by a variable number of frames. Each frame consists of a frame
+// header followed by a variable length payload. The length of the payload
+// is specified in the first four bytes of the frame header. The payload is
+// the raw compressed data.
+//
+// Standard Includes
+// -----------------
+// For encoders, you only have to include `vpx_encoder.h` and then any
+// header files for the specific codecs you use. In this case, we're using
+// vp8.
+//
+// Getting The Default Configuration
+// ---------------------------------
+// Encoders have the notion of "usage profiles." For example, an encoder
+// may want to publish default configurations for both a video
+// conferencing application and a best quality offline encoder. These
+// obviously have very different default settings. Consult the
+// documentation for your codec to see if it provides any default
+// configurations. All codecs provide a default configuration, number 0,
+// which is valid for material in the vacinity of QCIF/QVGA.
+//
+// Updating The Configuration
+// ---------------------------------
+// Almost all applications will want to update the default configuration
+// with settings specific to their usage. Here we set the width and height
+// of the video file to that specified on the command line. We also scale
+// the default bitrate based on the ratio between the default resolution
+// and the resolution specified on the command line.
+//
+// Initializing The Codec
+// ----------------------
+// The encoder is initialized by the following code.
+//
+// Encoding A Frame
+// ----------------
+// The frame is read as a continuous block (size width * height * 3 / 2)
+// from the input file. If a frame was read (the input file has not hit
+// EOF) then the frame is passed to the encoder. Otherwise, a NULL
+// is passed, indicating the End-Of-Stream condition to the encoder. The
+// `frame_cnt` is reused as the presentation time stamp (PTS) and each
+// frame is shown for one frame-time in duration. The flags parameter is
+// unused in this example. The deadline is set to VPX_DL_REALTIME to
+// make the example run as quickly as possible.
+
+// Forced Keyframes
+// ----------------
+// Keyframes can be forced by setting the VPX_EFLAG_FORCE_KF bit of the
+// flags passed to `vpx_codec_control()`. In this example, we force a
+// keyframe every <keyframe-interval> frames. Note, the output stream can
+// contain additional keyframes beyond those that have been forced using the
+// VPX_EFLAG_FORCE_KF flag because of automatic keyframe placement by the
+// encoder.
+//
+// Processing The Encoded Data
+// ---------------------------
+// Each packet of type `VPX_CODEC_CX_FRAME_PKT` contains the encoded data
+// for this frame. We write a IVF frame header, followed by the raw data.
+//
+// Cleanup
+// -------
+// The `vpx_codec_destroy` call frees any memory allocated by the codec.
+//
+// Error Handling
+// --------------
+// This example does not special case any error return codes. If there was
+// an error, a descriptive message is printed and the program exits. With
+// few exeptions, vpx_codec functions return an enumerated error status,
+// with the value `0` indicating success.
+//
+// Error Resiliency Features
+// -------------------------
+// Error resiliency is controlled by the g_error_resilient member of the
+// configuration structure. Use the `decode_with_drops` example to decode with
+// frames 5-10 dropped. Compare the output for a file encoded with this example
+// versus one encoded with the `simple_encoder` example.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "enc.h"
+
+static const char *exec_name = "./enc";
+
+void usage_exit(void) {
+  fprintf(stderr,
+          "Usage: %s <codec> <width> <height> <infile> <outfile> "
+          "<keyframe-interval> <error-resilient> <frames to encode>\n"
+          "See comments in simple_encoder.c for more information.\n",
+          exec_name);
+  exit(EXIT_FAILURE);
+}
+
+static VpxVideoWriter *writer;
+
+static VpxVideoWriter *open_writer(const char *file_name, uint32_t fourcc, int width, int height, int fps) {
+  VpxVideoInfo info = { 0, 0, 0, { 0, 0 } };
+  
+  info.codec_fourcc = fourcc;
+  info.frame_width = width;
+  info.frame_height = height;
+  info.time_base.numerator = 1;
+  info.time_base.denominator = fps;
+
+  return vpx_video_writer_open(file_name, kContainerIVF, &info);
+}
+
+// TODO(dkovalev): move this function to vpx_image.{c, h}, so it will be part
+// of vpx_image_t support
+int vpx_img_plane_width(const vpx_image_t *img, int plane) {
+  if (plane > 0 && img->x_chroma_shift > 0)
+    return (img->d_w + 1) >> img->x_chroma_shift;
+  else
+    return img->d_w;
+}
+
+int vpx_img_plane_height(const vpx_image_t *img, int plane) {
+  if (plane > 0 && img->y_chroma_shift > 0)
+    return (img->d_h + 1) >> img->y_chroma_shift;
+  else
+    return img->d_h;
+}
+
+int vpx_img_read(vpx_image_t *img, void *img_buf, int sz) {
+  int plane;
+
+  for (plane = 0; plane < 3; ++plane) {
+    unsigned char *buf = img->planes[plane];
+    const int stride = img->stride[plane];
+    const int w = vpx_img_plane_width(img, plane) *
+                  ((img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1);
+    const int h = vpx_img_plane_height(img, plane);
+    int y;
+
+    for (y = 0; y < h; ++y) {
+      memcpy(buf, img_buf, w);
+      img_buf += w;
+      buf += stride;
+    }
+  }
+
+  return 1;
+}
+
+int vpx_encode_frame(vpx_codec_ctx_t *codec, vpx_image_t *img, int frame_index, int flags) {
+  int got_pkts = 0;
+  vpx_codec_iter_t iter = NULL;
+  const vpx_codec_cx_pkt_t *pkt = NULL;
+  const vpx_codec_err_t res =
+      vpx_codec_encode(codec, img, frame_index, 1, flags, VPX_DL_REALTIME);
+  if (res != VPX_CODEC_OK) die_codec(codec, "Failed to encode frame");
+
+  while ((pkt = vpx_codec_get_cx_data(codec, &iter)) != NULL) {
+    got_pkts = 1;
+
+    if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) {
+      const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0;
+      if (!vpx_video_writer_write_frame(writer, pkt->data.frame.buf,
+                                        pkt->data.frame.sz,
+                                        pkt->data.frame.pts)) {
+        die_codec(codec, "Failed to write compressed frame");
+      }
+      printf(keyframe ? "K" : ".");
+      fflush(stdout);
+    }
+  }
+
+  return got_pkts;
+}
+
+
+void vpx_open(vpx_codec_ctx_t *codec, vpx_codec_iface_t *codec_interface, int width, int height, int fps, int bitrate, vpx_codec_er_flags_t err_resilient, vpx_image_t *raw) {
+  vpx_codec_enc_cfg_t cfg;
+  vpx_codec_err_t res;
+
+  res = vpx_codec_enc_config_default(codec_interface, &cfg, 0);
+  if (res) die("Failed to get default codec config.");
+
+  cfg.g_w = width;
+  cfg.g_h = height;
+  cfg.g_timebase.num = 1;
+  cfg.g_timebase.den = fps;
+  cfg.rc_target_bitrate = bitrate;
+  cfg.g_error_resilient = err_resilient;
+  cfg.rc_end_usage = VPX_CBR;
+
+  if (vpx_codec_enc_init(codec, codec_interface, &cfg, 0))
+    die_codec(codec, "Failed to initialize encoder");
+
+  if (vpx_codec_control(codec, VP8E_SET_CPUUSED, 8))
+    die_codec(codec, "Failed to initialize cpuused");
+
+  if (!vpx_img_alloc(raw, VPX_IMG_FMT_I420, width, height, 1)) {
+    die("Failed to allocate image.");
+  }
+}
+
+void vpx_close(vpx_codec_ctx_t *codec, vpx_image_t *raw) {
+  // Flush encoder.
+  while (vpx_encode_frame(codec, NULL, -1, 0)) {
+  }
+
+  vpx_img_free(raw);
+  if (vpx_codec_destroy(codec)) die_codec(codec, "Failed to destroy codec.");
+
+  vpx_video_writer_close(writer);
+}
+
+void vpx_init(const char *codec_arg, const char *outfile_arg, int width, int height, int fps) {
+  const VpxInterface *encoder = get_vpx_encoder_by_name(codec_arg);
+  if (!encoder) die("Unsupported codec.");
+  
+  writer = open_writer(outfile_arg, encoder->fourcc, width, height, fps);
+  if (!writer) die("Failed to open %s for writing.", outfile_arg);
+
+  printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface()));
+}
+
diff --git a/code/test/vid/enc.h b/code/test/vid/enc.h
new file mode 100644
index 0000000..d534971
--- /dev/null
+++ b/code/test/vid/enc.h
@@ -0,0 +1,10 @@
+#include "vpx/vpx_encoder.h"
+#include "vpx/vp8cx.h"
+#include "tools.h"
+#include "video_writer.h"
+
+int vpx_img_read(vpx_image_t *img, void *img_buf, int sz);
+int vpx_encode_frame(vpx_codec_ctx_t *codec, vpx_image_t *img, int frame_index, int flags);
+void vpx_open(vpx_codec_ctx_t *codec, vpx_codec_iface_t *codec_interface, int width, int height, int fps, int bitrate, vpx_codec_er_flags_t err_resilient, vpx_image_t *raw);
+void vpx_close(vpx_codec_ctx_t *codec, vpx_image_t *raw);
+void vpx_init(const char *codec_arg, const char *outfile_arg, int width, int height, int fps);
diff --git a/code/test/vid/tools.c b/code/test/vid/tools.c
new file mode 100644
index 0000000..6122209
--- /dev/null
+++ b/code/test/vid/tools.c
@@ -0,0 +1,54 @@
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "tools.h"
+
+static const VpxInterface vpx_encoders[] = {
+  { "vp8", VP8_FOURCC, &vpx_codec_vp8_cx },
+  { "vp9", VP9_FOURCC, &vpx_codec_vp9_cx },
+};
+
+int get_vpx_encoder_count(void) {
+  return sizeof(vpx_encoders) / sizeof(vpx_encoders[0]);
+}
+
+const VpxInterface *get_vpx_encoder_by_index(int i) { return &vpx_encoders[i]; }
+
+const VpxInterface *get_vpx_encoder_by_name(const char *name) {
+  int i;
+
+  for (i = 0; i < get_vpx_encoder_count(); ++i) {
+    const VpxInterface *encoder = get_vpx_encoder_by_index(i);
+    if (strcmp(encoder->name, name) == 0) return encoder;
+  }
+
+  return NULL;
+}
+
+#define LOG_ERROR(label)               \
+  do {                                 \
+    const char *l = label;             \
+    va_list ap;                        \
+    va_start(ap, fmt);                 \
+    if (l) fprintf(stderr, "%s: ", l); \
+    vfprintf(stderr, fmt, ap);         \
+    fprintf(stderr, "\n");             \
+    va_end(ap);                        \
+  } while (0)
+
+void die(const char *fmt, ...) {
+  LOG_ERROR(NULL);
+  usage_exit();
+}
+
+void die_codec(vpx_codec_ctx_t *ctx, const char *s) {
+  const char *detail = vpx_codec_error_detail(ctx);
+
+  printf("%s: %s\n", s, vpx_codec_error(ctx));
+  if (detail) printf("    %s\n", detail);
+  exit(EXIT_FAILURE);
+}
+
+    
\ No newline at end of file
diff --git a/code/test/vid/tools.h b/code/test/vid/tools.h
new file mode 100644
index 0000000..0bbf512
--- /dev/null
+++ b/code/test/vid/tools.h
@@ -0,0 +1,29 @@
+#ifndef TOOLS_COMMON_H_
+#define TOOLS_COMMON_H_
+
+#include "vpx/vpx_codec.h"
+#include "vpx/vpx_image.h"
+#include "vpx/vp8cx.h"
+
+#define VP8_FOURCC 0x30385056
+#define VP9_FOURCC 0x30395056
+
+struct VpxRational {
+  int numerator;
+  int denominator;
+};
+
+typedef struct VpxInterface {
+  const char *const name;
+  const uint32_t fourcc;
+  vpx_codec_iface_t *(*const codec_interface)();
+} VpxInterface;
+
+void usage_exit(void);
+const VpxInterface *get_vpx_encoder_by_index(int i);
+const VpxInterface *get_vpx_encoder_by_name(const char *name);
+
+void die(const char *fmt, ...);
+void die_codec(vpx_codec_ctx_t *ctx, const char *s);
+
+#endif
\ No newline at end of file
-- 
cgit v1.2.3