diff options
| -rw-r--r-- | code/test/vid/Makefile | 17 | ||||
| -rw-r--r-- | code/test/vid/cap.c | 568 | ||||
| -rwxr-xr-x | code/test/vid/cap.sh | 3 | ||||
| -rw-r--r-- | code/test/vid/enc.c | 239 | ||||
| -rw-r--r-- | code/test/vid/enc.h | 10 | ||||
| -rw-r--r-- | code/test/vid/tools.c | 54 | ||||
| -rw-r--r-- | code/test/vid/tools.h | 29 |
7 files changed, 920 insertions, 0 deletions
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 |