WebM Codec SDK
set_maps
1 /*
2  * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
3  *
4  * Use of this source code is governed by a BSD-style license
5  * that can be found in the LICENSE file in the root of the source
6  * tree. An additional intellectual property rights grant can be found
7  * in the file PATENTS. All contributing project authors may
8  * be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 
12 // VP8 Set Active and ROI Maps
13 // ===========================
14 //
15 // This is an example demonstrating how to control the VP8 encoder's
16 // ROI and Active maps.
17 //
18 // ROI (Reigon of Interest) maps are a way for the application to assign
19 // each macroblock in the image to a region, and then set quantizer and
20 // filtering parameters on that image.
21 //
22 // Active maps are a way for the application to specify on a
23 // macroblock-by-macroblock basis whether there is any activity in that
24 // macroblock.
25 //
26 //
27 // Configuration
28 // -------------
29 // An ROI map is set on frame 22. If the width of the image in macroblocks
30 // is evenly divisble by 4, then the output will appear to have distinct
31 // columns, where the quantizer, loopfilter, and static threshold differ
32 // from column to column.
33 //
34 // An active map is set on frame 33. If the width of the image in macroblocks
35 // is evenly divisble by 4, then the output will appear to have distinct
36 // columns, where one column will have motion and the next will not.
37 //
38 // The active map is cleared on frame 44.
39 //
40 // Observing The Effects
41 // ---------------------
42 // Use the `simple_decoder` example to decode this sample, and observe
43 // the change in the image at frames 22, 33, and 44.
44 
45 #include <assert.h>
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <string.h>
49 
50 #include "vpx/vp8cx.h"
51 #include "vpx/vpx_encoder.h"
52 
53 #include "../tools_common.h"
54 #include "../video_writer.h"
55 
56 static const char *exec_name;
57 
58 void usage_exit(void) {
59  fprintf(stderr, "Usage: %s <codec> <width> <height> <infile> <outfile>\n",
60  exec_name);
61  exit(EXIT_FAILURE);
62 }
63 
64 static void set_roi_map(const vpx_codec_enc_cfg_t *cfg,
65  vpx_codec_ctx_t *codec) {
66  unsigned int i;
67  vpx_roi_map_t roi;
68  memset(&roi, 0, sizeof(roi));
69 
70  roi.rows = (cfg->g_h + 15) / 16;
71  roi.cols = (cfg->g_w + 15) / 16;
72 
73  roi.delta_q[0] = 0;
74  roi.delta_q[1] = -2;
75  roi.delta_q[2] = -4;
76  roi.delta_q[3] = -6;
77 
78  roi.delta_lf[0] = 0;
79  roi.delta_lf[1] = 1;
80  roi.delta_lf[2] = 2;
81  roi.delta_lf[3] = 3;
82 
83  roi.static_threshold[0] = 1500;
84  roi.static_threshold[1] = 1000;
85  roi.static_threshold[2] = 500;
86  roi.static_threshold[3] = 0;
87 
88  roi.roi_map = (uint8_t *)malloc(roi.rows * roi.cols);
89  for (i = 0; i < roi.rows * roi.cols; ++i)
90  roi.roi_map[i] = i % 4;
91 
92  if (vpx_codec_control(codec, VP8E_SET_ROI_MAP, &roi))
93  die_codec(codec, "Failed to set ROI map");
94 
95  free(roi.roi_map);
96 }
97 
98 static void set_active_map(const vpx_codec_enc_cfg_t *cfg,
99  vpx_codec_ctx_t *codec) {
100  unsigned int i;
101  vpx_active_map_t map = {0, 0, 0};
102 
103  map.rows = (cfg->g_h + 15) / 16;
104  map.cols = (cfg->g_w + 15) / 16;
105 
106  map.active_map = (uint8_t *)malloc(map.rows * map.cols);
107  for (i = 0; i < map.rows * map.cols; ++i)
108  map.active_map[i] = i % 2;
109 
110  if (vpx_codec_control(codec, VP8E_SET_ACTIVEMAP, &map))
111  die_codec(codec, "Failed to set active map");
112 
113  free(map.active_map);
114 }
115 
116 static void unset_active_map(const vpx_codec_enc_cfg_t *cfg,
117  vpx_codec_ctx_t *codec) {
118  vpx_active_map_t map = {0, 0, 0};
119 
120  map.rows = (cfg->g_h + 15) / 16;
121  map.cols = (cfg->g_w + 15) / 16;
122  map.active_map = NULL;
123 
124  if (vpx_codec_control(codec, VP8E_SET_ACTIVEMAP, &map))
125  die_codec(codec, "Failed to set active map");
126 }
127 
128 static int encode_frame(vpx_codec_ctx_t *codec,
129  vpx_image_t *img,
130  int frame_index,
131  VpxVideoWriter *writer) {
132  int got_pkts = 0;
133  vpx_codec_iter_t iter = NULL;
134  const vpx_codec_cx_pkt_t *pkt = NULL;
135  const vpx_codec_err_t res = vpx_codec_encode(codec, img, frame_index, 1, 0,
137  if (res != VPX_CODEC_OK)
138  die_codec(codec, "Failed to encode frame");
139 
140  while ((pkt = vpx_codec_get_cx_data(codec, &iter)) != NULL) {
141  got_pkts = 1;
142 
143  if (pkt->kind == VPX_CODEC_CX_FRAME_PKT) {
144  const int keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0;
145  if (!vpx_video_writer_write_frame(writer,
146  pkt->data.frame.buf,
147  pkt->data.frame.sz,
148  pkt->data.frame.pts)) {
149  die_codec(codec, "Failed to write compressed frame");
150  }
151 
152  printf(keyframe ? "K" : ".");
153  fflush(stdout);
154  }
155  }
156 
157  return got_pkts;
158 }
159 
160 int main(int argc, char **argv) {
161  FILE *infile = NULL;
162  vpx_codec_ctx_t codec;
164  int frame_count = 0;
165  vpx_image_t raw;
166  vpx_codec_err_t res;
167  VpxVideoInfo info;
168  VpxVideoWriter *writer = NULL;
169  const VpxInterface *encoder = NULL;
170  const int fps = 2; // TODO(dkovalev) add command line argument
171  const double bits_per_pixel_per_frame = 0.067;
172 
173  exec_name = argv[0];
174  if (argc != 6)
175  die("Invalid number of arguments");
176 
177  memset(&info, 0, sizeof(info));
178 
179  encoder = get_vpx_encoder_by_name(argv[1]);
180  if (encoder == NULL) {
181  die("Unsupported codec.");
182  }
183  assert(encoder != NULL);
184  info.codec_fourcc = encoder->fourcc;
185  info.frame_width = strtol(argv[2], NULL, 0);
186  info.frame_height = strtol(argv[3], NULL, 0);
187  info.time_base.numerator = 1;
188  info.time_base.denominator = fps;
189 
190  if (info.frame_width <= 0 ||
191  info.frame_height <= 0 ||
192  (info.frame_width % 2) != 0 ||
193  (info.frame_height % 2) != 0) {
194  die("Invalid frame size: %dx%d", info.frame_width, info.frame_height);
195  }
196 
197  if (!vpx_img_alloc(&raw, VPX_IMG_FMT_I420, info.frame_width,
198  info.frame_height, 1)) {
199  die("Failed to allocate image.");
200  }
201 
202  printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface()));
203 
204  res = vpx_codec_enc_config_default(encoder->codec_interface(), &cfg, 0);
205  if (res)
206  die_codec(&codec, "Failed to get default codec config.");
207 
208  cfg.g_w = info.frame_width;
209  cfg.g_h = info.frame_height;
210  cfg.g_timebase.num = info.time_base.numerator;
211  cfg.g_timebase.den = info.time_base.denominator;
212  cfg.rc_target_bitrate = (unsigned int)(bits_per_pixel_per_frame * cfg.g_w *
213  cfg.g_h * fps / 1000);
214  cfg.g_lag_in_frames = 0;
215 
216  writer = vpx_video_writer_open(argv[5], kContainerIVF, &info);
217  if (!writer)
218  die("Failed to open %s for writing.", argv[5]);
219 
220  if (!(infile = fopen(argv[4], "rb")))
221  die("Failed to open %s for reading.", argv[4]);
222 
223  if (vpx_codec_enc_init(&codec, encoder->codec_interface(), &cfg, 0))
224  die_codec(&codec, "Failed to initialize encoder");
225 
226  // Encode frames.
227  while (vpx_img_read(&raw, infile)) {
228  ++frame_count;
229 
230  if (frame_count == 22 && encoder->fourcc == VP8_FOURCC) {
231  set_roi_map(&cfg, &codec);
232  } else if (frame_count == 33) {
233  set_active_map(&cfg, &codec);
234  } else if (frame_count == 44) {
235  unset_active_map(&cfg, &codec);
236  }
237 
238  encode_frame(&codec, &raw, frame_count, writer);
239  }
240 
241  // Flush encoder.
242  while (encode_frame(&codec, NULL, -1, writer)) {}
243 
244  printf("\n");
245  fclose(infile);
246  printf("Processed %d frames.\n", frame_count);
247 
248  vpx_img_free(&raw);
249  if (vpx_codec_destroy(&codec))
250  die_codec(&codec, "Failed to destroy codec.");
251 
252  vpx_video_writer_close(writer);
253 
254  return EXIT_SUCCESS;
255 }
unsigned char * roi_map
Definition: vp8cx.h:605
Image Descriptor.
Definition: vpx_image.h:88
Describes the encoder algorithm interface to applications.
const char * vpx_codec_iface_name(vpx_codec_iface_t *iface)
Return the name for a given interface.
unsigned int cols
Definition: vp8cx.h:627
struct vpx_rational g_timebase
Stream timebase units.
Definition: vpx_encoder.h:397
unsigned int cols
Definition: vp8cx.h:607
int den
Definition: vpx_encoder.h:261
vpx_codec_err_t vpx_codec_encode(vpx_codec_ctx_t *ctx, const vpx_image_t *img, vpx_codec_pts_t pts, unsigned long duration, vpx_enc_frame_flags_t flags, unsigned long deadline)
Encode a frame.
Codec control function to pass an ROI map to encoder.
Definition: vp8cx.h:148
unsigned int g_lag_in_frames
Allow lagged encoding.
Definition: vpx_encoder.h:429
Encoder configuration structure.
Definition: vpx_encoder.h:314
Encoder output packet.
Definition: vpx_encoder.h:195
struct vpx_codec_cx_pkt::@1::@2 frame
vpx_image_t * vpx_img_alloc(vpx_image_t *img, vpx_img_fmt_t fmt, unsigned int d_w, unsigned int d_h, unsigned int align)
Open a descriptor, allocating storage for the underlying image.
Definition: vpx_image.h:56
unsigned int g_w
Width of the frame.
Definition: vpx_encoder.h:357
unsigned int static_threshold[4]
Definition: vp8cx.h:614
unsigned int g_h
Height of the frame.
Definition: vpx_encoder.h:367
enum vpx_codec_cx_pkt_kind kind
Definition: vpx_encoder.h:196
Operation completed without error.
Definition: vpx_codec.h:91
void vpx_img_free(vpx_image_t *img)
Close an image descriptor.
unsigned int rc_target_bitrate
Target data rate.
Definition: vpx_encoder.h:525
int num
Definition: vpx_encoder.h:260
int delta_lf[4]
Definition: vp8cx.h:612
#define VPX_DL_GOOD_QUALITY
Definition: vpx_encoder.h:914
Provides definitions for using VP8 or VP9 encoder algorithm within the vpx Codec Interface.
unsigned char * active_map
Definition: vp8cx.h:625
#define vpx_codec_enc_init(ctx, iface, cfg, flags)
Convenience macro for vpx_codec_enc_init_ver()
Definition: vpx_encoder.h:813
vpx_codec_err_t
Algorithm return codes.
Definition: vpx_codec.h:89
const vpx_codec_cx_pkt_t * vpx_codec_get_cx_data(vpx_codec_ctx_t *ctx, vpx_codec_iter_t *iter)
Encoded data iterator.
unsigned int rows
Definition: vp8cx.h:626
union vpx_codec_cx_pkt::@1 data
vpx_codec_err_t vpx_codec_enc_config_default(vpx_codec_iface_t *iface, vpx_codec_enc_cfg_t *cfg, unsigned int reserved)
Get a default configuration.
vpx active region map
Definition: vp8cx.h:624
#define vpx_codec_control(ctx, id, data)
vpx_codec_control wrapper macro
Definition: vpx_codec.h:407
vpx_codec_err_t vpx_codec_destroy(vpx_codec_ctx_t *ctx)
Destroy a codec instance.
unsigned int rows
Definition: vp8cx.h:606
#define VPX_FRAME_IS_KEY
Definition: vpx_encoder.h:130
const void * vpx_codec_iter_t
Iterator.
Definition: vpx_codec.h:188
vpx region of interest map
Definition: vp8cx.h:603
Definition: vpx_encoder.h:176
int delta_q[4]
Definition: vp8cx.h:611
Codec control function to pass an Active map to encoder.
Definition: vp8cx.h:154
Codec context structure.
Definition: vpx_codec.h:199