granicus.if.org Git - libvpx/blob - examples/set_maps.c

   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() {
  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,
 136                                                VPX_DL_GOOD_QUALITY);
 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;
 163   vpx_codec_enc_cfg_t cfg;
 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 }