examples/vp8_multi_resolution_encoder.c - avm - Git at Google

 /*
  *  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.
  */


 // This is an example demonstrating multi-resolution encoding in VP8.
 // High-resolution input video is down-sampled to lower-resolutions. The
 // encoder then encodes the video and outputs multiple bitstreams with
 // different resolutions.
 //
 // Configure with --enable-multi-res-encoding flag to enable this example.

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 #include "third_party/libyuv/include/libyuv/basic_types.h"
 #include "third_party/libyuv/include/libyuv/scale.h"
 #include "third_party/libyuv/include/libyuv/cpu_id.h"

 #define VPX_CODEC_DISABLE_COMPAT 1
 #include "vpx/vpx_encoder.h"
 #include "vpx/vp8cx.h"

 #include "./tools_common.h"
 #include "./video_writer.h"

 static const char *exec_name;

 void usage_exit() {
   fprintf(stderr,
           "Usage: %s <width> <height> <infile> <outfile(s)> <output psnr?>\n",
           exec_name);
   exit(EXIT_FAILURE);
 }

 int main(int argc, char *argv[]) {
   // The input video frame is downsampled several times to generate a
   // multi-level  hierarchical structure. kNumEncoders is defined as the number
   // of encoding  levels required. For example, if the size of input video is
   // 1280x720, kNumEncoders is 3, and down-sampling factor is 2, the encoder
   // outputs 3 bitstreams with resolution of 1280x720(level 0),
   // 640x360(level 1), and 320x180(level 2) respectively.
   static const int kNumEncoders = 3;

   int frame_cnt = 0;
   FILE *infile = NULL;
   VpxVideoWriter *writers[kNumEncoders];
   vpx_codec_ctx_t codec[kNumEncoders];
   vpx_codec_enc_cfg_t cfg[kNumEncoders];
   vpx_image_t raw[kNumEncoders];
   const VpxInterface *const encoder = get_vpx_encoder_by_name("vp8");
   // Currently, only realtime mode is supported in multi-resolution encoding.
   const int arg_deadline = VPX_DL_REALTIME;
   int i;
   int width = 0;
   int height = 0;
   int frame_avail = 0;
   int got_data = 0;

   // Set show_psnr to 1/0 to show/not show PSNR. Choose show_psnr=0 if you
   // don't need to know PSNR, which will skip PSNR calculation and save
   // encoding time.
   int show_psnr = 0;
   uint64_t psnr_sse_total[kNumEncoders] = {0};
   uint64_t psnr_samples_total[kNumEncoders] = {0};
   double psnr_totals[kNumEncoders][4] = {{0, 0}};
   int psnr_count[kNumEncoders] = {0};

   // Set the required target bitrates for each resolution level.
   // If target bitrate for highest-resolution level is set to 0,
   // (i.e. target_bitrate[0]=0), we skip encoding at that level.
   unsigned int target_bitrate[kNumEncoders] = {1000, 500, 100};

   // Enter the frame rate of the input video.
   const int framerate = 30;
   // Set down-sampling factor for each resolution level.
   //   dsf[0] controls down sampling from level 0 to level 1;
   //   dsf[1] controls down sampling from level 1 to level 2;
   //   dsf[2] is not used.
   vpx_rational_t dsf[kNumEncoders] = {{2, 1}, {2, 1}, {1, 1}};

   exec_name = argv[0];

   if (!encoder)
     die("Unsupported codec.");

   // exe_name, input width, input height, input file,
   // output file 1, output file 2, output file 3, psnr on/off
   if (argc != (5 + kNumEncoders))
     die("Invalid number of input options.");

   printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface()));

   width = strtol(argv[1], NULL, 0);
   height = strtol(argv[2], NULL, 0);

   if (width < 16 || width % 2 || height < 16 || height % 2)
     die("Invalid resolution: %ldx%ld", width, height);

   // Open input video file for encoding
   if (!(infile = fopen(argv[3], "rb")))
     die("Failed to open %s for reading", argv[3]);

   show_psnr = strtol(argv[kNumEncoders + 4], NULL, 0);

   // Populate default encoder configuration
   for (i = 0; i < kNumEncoders; ++i) {
     vpx_codec_err_t res =
         vpx_codec_enc_config_default(encoder->codec_interface(), &cfg[i], 0);
     if (res != VPX_CODEC_OK) {
       printf("Failed to get config: %s\n", vpx_codec_err_to_string(res));
       return EXIT_FAILURE;
     }
   }

   // Update the default configuration according to needs of the application.
   // Highest-resolution encoder settings
   cfg[0].g_w = width;
   cfg[0].g_h = height;
   cfg[0].g_threads = 1;
   cfg[0].rc_dropframe_thresh = 30;
   cfg[0].rc_end_usage = VPX_CBR;
   cfg[0].rc_resize_allowed = 0;
   cfg[0].rc_min_quantizer = 4;
   cfg[0].rc_max_quantizer = 56;
   cfg[0].rc_undershoot_pct = 98;
   cfg[0].rc_overshoot_pct = 100;
   cfg[0].rc_buf_initial_sz = 500;
   cfg[0].rc_buf_optimal_sz = 600;
   cfg[0].rc_buf_sz = 1000;
   cfg[0].g_error_resilient = 1;
   cfg[0].g_lag_in_frames = 0;
   cfg[0].kf_mode = VPX_KF_AUTO;  // VPX_KF_DISABLED
   cfg[0].kf_min_dist = 3000;
   cfg[0].kf_max_dist = 3000;
   cfg[0].rc_target_bitrate = target_bitrate[0];
   cfg[0].g_timebase.num = 1;
   cfg[0].g_timebase.den = framerate;

   // Other-resolution encoder settings
   for (i = 1; i < kNumEncoders; ++i) {
     cfg[i] = cfg[0];
     cfg[i].g_threads = 1;
     cfg[i].rc_target_bitrate = target_bitrate[i];

     // Note: Width & height of other-resolution encoders are calculated
     // from the highest-resolution encoder's size and the corresponding
     // down_sampling_factor.
     {
       unsigned int iw = cfg[i - 1].g_w * dsf[i - 1].den + dsf[i - 1].num - 1;
       unsigned int ih = cfg[i - 1].g_h * dsf[i - 1].den + dsf[i - 1].num - 1;
       cfg[i].g_w = iw / dsf[i - 1].num;
       cfg[i].g_h = ih / dsf[i - 1].num;
     }

     // Make width & height to be multiplier of 2.
     if ((cfg[i].g_w) % 2)
       cfg[i].g_w++;

     if ((cfg[i].g_h) % 2)
       cfg[i].g_h++;
   }

   // Open output file for each encoder to output bitstreams
   for (i = 0; i < kNumEncoders; ++i) {
     VpxVideoInfo info = {
       encoder->fourcc,
       cfg[i].g_w,
       cfg[i].g_h,
       {cfg[i].g_timebase.num, cfg[i].g_timebase.den}
     };

     if (!(writers[i] = vpx_video_writer_open(argv[i+4], kContainerIVF, &info)))
       die("Failed to open %s for writing", argv[i+4]);
   }

   // Allocate image for each encoder
   for (i = 0; i < kNumEncoders; ++i)
     if (!vpx_img_alloc(&raw[i], VPX_IMG_FMT_I420, cfg[i].g_w, cfg[i].g_h, 32))
       die("Failed to allocate image", cfg[i].g_w, cfg[i].g_h);

   // Initialize multi-encoder
   if (vpx_codec_enc_init_multi(&codec[0], encoder->codec_interface(), &cfg[0],
                                kNumEncoders,
                                show_psnr ? VPX_CODEC_USE_PSNR : 0, &dsf[0]))
     die_codec(&codec[0], "Failed to initialize encoder");

   // The extra encoding configuration parameters can be set as follows.
   for (i = 0; i < kNumEncoders; i++) {
     // Set encoding speed
     if (vpx_codec_control(&codec[i], VP8E_SET_CPUUSED, -6))
       die_codec(&codec[i], "Failed to set cpu_used");

     // Set static threshold.
     if (vpx_codec_control(&codec[i], VP8E_SET_STATIC_THRESHOLD, 1))
       die_codec(&codec[i], "Failed to set static threshold");

     // Set NOISE_SENSITIVITY to do TEMPORAL_DENOISING
     // Enable denoising for the highest-resolution encoder.
     if (vpx_codec_control(&codec[0], VP8E_SET_NOISE_SENSITIVITY, i == 0))
       die_codec(&codec[0], "Failed to set noise_sensitivity");
   }

   frame_avail = 1;
   got_data = 0;

   while (frame_avail || got_data) {
     vpx_codec_iter_t iter[kNumEncoders] = {NULL};
     const vpx_codec_cx_pkt_t *pkt[kNumEncoders];

     frame_avail = vpx_img_read(&raw[0], infile);

     if (frame_avail) {
       for (i = 1; i < kNumEncoders; ++i) {
         vpx_image_t *const prev = &raw[i - 1];

         // Scale the image down a number of times by downsampling factor
         // FilterMode 1 or 2 give better psnr than FilterMode 0.
         I420Scale(prev->planes[VPX_PLANE_Y], prev->stride[VPX_PLANE_Y],
                   prev->planes[VPX_PLANE_U], prev->stride[VPX_PLANE_U],
                   prev->planes[VPX_PLANE_V], prev->stride[VPX_PLANE_V],
                   prev->d_w, prev->d_h,
                   raw[i].planes[VPX_PLANE_Y], raw[i].stride[VPX_PLANE_Y],
                   raw[i].planes[VPX_PLANE_U], raw[i].stride[VPX_PLANE_U],
                   raw[i].planes[VPX_PLANE_V], raw[i].stride[VPX_PLANE_V],
                   raw[i].d_w, raw[i].d_h, 1);
       }
     }

     // Encode frame.
     if (vpx_codec_encode(&codec[0], frame_avail? &raw[0] : NULL,
                          frame_cnt, 1, 0, arg_deadline)) {
       die_codec(&codec[0], "Failed to encode frame");
     }

     for (i = kNumEncoders - 1; i >= 0; i--) {
       got_data = 0;

       while ((pkt[i] = vpx_codec_get_cx_data(&codec[i], &iter[i]))) {
         got_data = 1;
         switch (pkt[i]->kind) {
           case VPX_CODEC_CX_FRAME_PKT:
             vpx_video_writer_write_frame(writers[i], pkt[i]->data.frame.buf,
                                          pkt[i]->data.frame.sz, frame_cnt - 1);
           break;
           case VPX_CODEC_PSNR_PKT:
             if (show_psnr) {
               int j;
               psnr_sse_total[i] += pkt[i]->data.psnr.sse[0];
               psnr_samples_total[i] += pkt[i]->data.psnr.samples[0];
               for (j = 0; j < 4; j++)
                 psnr_totals[i][j] += pkt[i]->data.psnr.psnr[j];
               psnr_count[i]++;
             }
             break;
           default:
             break;
         }
         printf(pkt[i]->kind == VPX_CODEC_CX_FRAME_PKT &&
                (pkt[i]->data.frame.flags & VPX_FRAME_IS_KEY)? "K":".");
         fflush(stdout);
       }
     }
     frame_cnt++;
   }
   printf("\n");

   fclose(infile);

   printf("Processed %d frames.\n", frame_cnt - 1);
   for (i = 0; i < kNumEncoders; ++i) {
     // Calculate PSNR and print it out
     if (show_psnr && psnr_count[i] > 0) {
       int j;
       double ovpsnr = sse_to_psnr(psnr_samples_total[i], 255.0,
                                   psnr_sse_total[i]);

       fprintf(stderr, "\n ENC%d PSNR (Overall/Avg/Y/U/V)", i);
       fprintf(stderr, " %.3lf", ovpsnr);
       for (j = 0; j < 4; j++)
         fprintf(stderr, " %.3lf", psnr_totals[i][j]/psnr_count[i]);
     }

     if (vpx_codec_destroy(&codec[i]))
       die_codec(&codec[i], "Failed to destroy codec");

     vpx_img_free(&raw[i]);
     vpx_video_writer_close(writers[i]);
   }
   printf("\n");

   return EXIT_SUCCESS;
 }
	/*
	* 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.
	*/


	// This is an example demonstrating multi-resolution encoding in VP8.
	// High-resolution input video is down-sampled to lower-resolutions. The
	// encoder then encodes the video and outputs multiple bitstreams with
	// different resolutions.
	//
	// Configure with --enable-multi-res-encoding flag to enable this example.

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#include "third_party/libyuv/include/libyuv/basic_types.h"
	#include "third_party/libyuv/include/libyuv/scale.h"
	#include "third_party/libyuv/include/libyuv/cpu_id.h"

	#define VPX_CODEC_DISABLE_COMPAT 1
	#include "vpx/vpx_encoder.h"
	#include "vpx/vp8cx.h"

	#include "./tools_common.h"
	#include "./video_writer.h"

	static const char *exec_name;

	void usage_exit() {
	fprintf(stderr,
	"Usage: %s <width> <height> <infile> <outfile(s)> <output psnr?>\n",
	exec_name);
	exit(EXIT_FAILURE);
	}

	int main(int argc, char *argv[]) {
	// The input video frame is downsampled several times to generate a
	// multi-level hierarchical structure. kNumEncoders is defined as the number
	// of encoding levels required. For example, if the size of input video is
	// 1280x720, kNumEncoders is 3, and down-sampling factor is 2, the encoder
	// outputs 3 bitstreams with resolution of 1280x720(level 0),
	// 640x360(level 1), and 320x180(level 2) respectively.
	static const int kNumEncoders = 3;

	int frame_cnt = 0;
	FILE *infile = NULL;
	VpxVideoWriter *writers[kNumEncoders];
	vpx_codec_ctx_t codec[kNumEncoders];
	vpx_codec_enc_cfg_t cfg[kNumEncoders];
	vpx_image_t raw[kNumEncoders];
	const VpxInterface *const encoder = get_vpx_encoder_by_name("vp8");
	// Currently, only realtime mode is supported in multi-resolution encoding.
	const int arg_deadline = VPX_DL_REALTIME;
	int i;
	int width = 0;
	int height = 0;
	int frame_avail = 0;
	int got_data = 0;

	// Set show_psnr to 1/0 to show/not show PSNR. Choose show_psnr=0 if you
	// don't need to know PSNR, which will skip PSNR calculation and save
	// encoding time.
	int show_psnr = 0;
	uint64_t psnr_sse_total[kNumEncoders] = {0};
	uint64_t psnr_samples_total[kNumEncoders] = {0};
	double psnr_totals[kNumEncoders][4] = {{0, 0}};
	int psnr_count[kNumEncoders] = {0};

	// Set the required target bitrates for each resolution level.
	// If target bitrate for highest-resolution level is set to 0,
	// (i.e. target_bitrate[0]=0), we skip encoding at that level.
	unsigned int target_bitrate[kNumEncoders] = {1000, 500, 100};

	// Enter the frame rate of the input video.
	const int framerate = 30;
	// Set down-sampling factor for each resolution level.
	// dsf[0] controls down sampling from level 0 to level 1;
	// dsf[1] controls down sampling from level 1 to level 2;
	// dsf[2] is not used.
	vpx_rational_t dsf[kNumEncoders] = {{2, 1}, {2, 1}, {1, 1}};

	exec_name = argv[0];

	if (!encoder)
	die("Unsupported codec.");

	// exe_name, input width, input height, input file,
	// output file 1, output file 2, output file 3, psnr on/off
	if (argc != (5 + kNumEncoders))
	die("Invalid number of input options.");

	printf("Using %s\n", vpx_codec_iface_name(encoder->codec_interface()));

	width = strtol(argv[1], NULL, 0);
	height = strtol(argv[2], NULL, 0);

	if (width < 16 \|\| width % 2 \|\| height < 16 \|\| height % 2)
	die("Invalid resolution: %ldx%ld", width, height);

	// Open input video file for encoding
	if (!(infile = fopen(argv[3], "rb")))
	die("Failed to open %s for reading", argv[3]);

	show_psnr = strtol(argv[kNumEncoders + 4], NULL, 0);

	// Populate default encoder configuration
	for (i = 0; i < kNumEncoders; ++i) {
	vpx_codec_err_t res =
	vpx_codec_enc_config_default(encoder->codec_interface(), &cfg[i], 0);
	if (res != VPX_CODEC_OK) {
	printf("Failed to get config: %s\n", vpx_codec_err_to_string(res));
	return EXIT_FAILURE;
	}
	}

	// Update the default configuration according to needs of the application.
	// Highest-resolution encoder settings
	cfg[0].g_w = width;
	cfg[0].g_h = height;
	cfg[0].g_threads = 1;
	cfg[0].rc_dropframe_thresh = 30;
	cfg[0].rc_end_usage = VPX_CBR;
	cfg[0].rc_resize_allowed = 0;
	cfg[0].rc_min_quantizer = 4;
	cfg[0].rc_max_quantizer = 56;
	cfg[0].rc_undershoot_pct = 98;
	cfg[0].rc_overshoot_pct = 100;
	cfg[0].rc_buf_initial_sz = 500;
	cfg[0].rc_buf_optimal_sz = 600;
	cfg[0].rc_buf_sz = 1000;
	cfg[0].g_error_resilient = 1;
	cfg[0].g_lag_in_frames = 0;
	cfg[0].kf_mode = VPX_KF_AUTO; // VPX_KF_DISABLED
	cfg[0].kf_min_dist = 3000;
	cfg[0].kf_max_dist = 3000;
	cfg[0].rc_target_bitrate = target_bitrate[0];
	cfg[0].g_timebase.num = 1;
	cfg[0].g_timebase.den = framerate;

	// Other-resolution encoder settings
	for (i = 1; i < kNumEncoders; ++i) {
	cfg[i] = cfg[0];
	cfg[i].g_threads = 1;
	cfg[i].rc_target_bitrate = target_bitrate[i];

	// Note: Width & height of other-resolution encoders are calculated
	// from the highest-resolution encoder's size and the corresponding
	// down_sampling_factor.
	{
	unsigned int iw = cfg[i - 1].g_w * dsf[i - 1].den + dsf[i - 1].num - 1;
	unsigned int ih = cfg[i - 1].g_h * dsf[i - 1].den + dsf[i - 1].num - 1;
	cfg[i].g_w = iw / dsf[i - 1].num;
	cfg[i].g_h = ih / dsf[i - 1].num;
	}

	// Make width & height to be multiplier of 2.
	if ((cfg[i].g_w) % 2)
	cfg[i].g_w++;

	if ((cfg[i].g_h) % 2)
	cfg[i].g_h++;
	}

	// Open output file for each encoder to output bitstreams
	for (i = 0; i < kNumEncoders; ++i) {
	VpxVideoInfo info = {
	encoder->fourcc,
	cfg[i].g_w,
	cfg[i].g_h,
	{cfg[i].g_timebase.num, cfg[i].g_timebase.den}
	};

	if (!(writers[i] = vpx_video_writer_open(argv[i+4], kContainerIVF, &info)))
	die("Failed to open %s for writing", argv[i+4]);
	}

	// Allocate image for each encoder
	for (i = 0; i < kNumEncoders; ++i)
	if (!vpx_img_alloc(&raw[i], VPX_IMG_FMT_I420, cfg[i].g_w, cfg[i].g_h, 32))
	die("Failed to allocate image", cfg[i].g_w, cfg[i].g_h);

	// Initialize multi-encoder
	if (vpx_codec_enc_init_multi(&codec[0], encoder->codec_interface(), &cfg[0],
	kNumEncoders,
	show_psnr ? VPX_CODEC_USE_PSNR : 0, &dsf[0]))
	die_codec(&codec[0], "Failed to initialize encoder");

	// The extra encoding configuration parameters can be set as follows.
	for (i = 0; i < kNumEncoders; i++) {
	// Set encoding speed
	if (vpx_codec_control(&codec[i], VP8E_SET_CPUUSED, -6))
	die_codec(&codec[i], "Failed to set cpu_used");

	// Set static threshold.
	if (vpx_codec_control(&codec[i], VP8E_SET_STATIC_THRESHOLD, 1))
	die_codec(&codec[i], "Failed to set static threshold");

	// Set NOISE_SENSITIVITY to do TEMPORAL_DENOISING
	// Enable denoising for the highest-resolution encoder.
	if (vpx_codec_control(&codec[0], VP8E_SET_NOISE_SENSITIVITY, i == 0))
	die_codec(&codec[0], "Failed to set noise_sensitivity");
	}

	frame_avail = 1;
	got_data = 0;

	while (frame_avail \|\| got_data) {
	vpx_codec_iter_t iter[kNumEncoders] = {NULL};
	const vpx_codec_cx_pkt_t *pkt[kNumEncoders];

	frame_avail = vpx_img_read(&raw[0], infile);

	if (frame_avail) {
	for (i = 1; i < kNumEncoders; ++i) {
	vpx_image_t *const prev = &raw[i - 1];

	// Scale the image down a number of times by downsampling factor
	// FilterMode 1 or 2 give better psnr than FilterMode 0.
	I420Scale(prev->planes[VPX_PLANE_Y], prev->stride[VPX_PLANE_Y],
	prev->planes[VPX_PLANE_U], prev->stride[VPX_PLANE_U],
	prev->planes[VPX_PLANE_V], prev->stride[VPX_PLANE_V],
	prev->d_w, prev->d_h,
	raw[i].planes[VPX_PLANE_Y], raw[i].stride[VPX_PLANE_Y],
	raw[i].planes[VPX_PLANE_U], raw[i].stride[VPX_PLANE_U],
	raw[i].planes[VPX_PLANE_V], raw[i].stride[VPX_PLANE_V],
	raw[i].d_w, raw[i].d_h, 1);
	}
	}

	// Encode frame.
	if (vpx_codec_encode(&codec[0], frame_avail? &raw[0] : NULL,
	frame_cnt, 1, 0, arg_deadline)) {
	die_codec(&codec[0], "Failed to encode frame");
	}

	for (i = kNumEncoders - 1; i >= 0; i--) {
	got_data = 0;

	while ((pkt[i] = vpx_codec_get_cx_data(&codec[i], &iter[i]))) {
	got_data = 1;
	switch (pkt[i]->kind) {
	case VPX_CODEC_CX_FRAME_PKT:
	vpx_video_writer_write_frame(writers[i], pkt[i]->data.frame.buf,
	pkt[i]->data.frame.sz, frame_cnt - 1);
	break;
	case VPX_CODEC_PSNR_PKT:
	if (show_psnr) {
	int j;
	psnr_sse_total[i] += pkt[i]->data.psnr.sse[0];
	psnr_samples_total[i] += pkt[i]->data.psnr.samples[0];
	for (j = 0; j < 4; j++)
	psnr_totals[i][j] += pkt[i]->data.psnr.psnr[j];
	psnr_count[i]++;
	}
	break;
	default:
	break;
	}
	printf(pkt[i]->kind == VPX_CODEC_CX_FRAME_PKT &&
	(pkt[i]->data.frame.flags & VPX_FRAME_IS_KEY)? "K":".");
	fflush(stdout);
	}
	}
	frame_cnt++;
	}
	printf("\n");

	fclose(infile);

	printf("Processed %d frames.\n", frame_cnt - 1);
	for (i = 0; i < kNumEncoders; ++i) {
	// Calculate PSNR and print it out
	if (show_psnr && psnr_count[i] > 0) {
	int j;
	double ovpsnr = sse_to_psnr(psnr_samples_total[i], 255.0,
	psnr_sse_total[i]);

	fprintf(stderr, "\n ENC%d PSNR (Overall/Avg/Y/U/V)", i);
	fprintf(stderr, " %.3lf", ovpsnr);
	for (j = 0; j < 4; j++)
	fprintf(stderr, " %.3lf", psnr_totals[i][j]/psnr_count[i]);
	}

	if (vpx_codec_destroy(&codec[i]))
	die_codec(&codec[i], "Failed to destroy codec");

	vpx_img_free(&raw[i]);
	vpx_video_writer_close(writers[i]);
	}
	printf("\n");

	return EXIT_SUCCESS;
	}