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#include <math.h> 12#include <stdarg.h> 13#include <stdio.h> 14#include <stdlib.h> 15#include <string.h> 16 17#include "./tools_common.h" 18 19#if CONFIG_VP8_ENCODER || CONFIG_VP9_ENCODER 20#include "vpx/vp8cx.h" 21#endif 22 23#if CONFIG_VP8_DECODER || CONFIG_VP9_DECODER 24#include "vpx/vp8dx.h" 25#endif 26 27#if defined(_WIN32) || defined(__OS2__) 28#include <io.h> 29#include <fcntl.h> 30 31#ifdef __OS2__ 32#define _setmode setmode 33#define _fileno fileno 34#define _O_BINARY O_BINARY 35#endif 36#endif 37 38#define LOG_ERROR(label) do {\ 39 const char *l = label;\ 40 va_list ap;\ 41 va_start(ap, fmt);\ 42 if (l)\ 43 fprintf(stderr, "%s: ", l);\ 44 vfprintf(stderr, fmt, ap);\ 45 fprintf(stderr, "\n");\ 46 va_end(ap);\ 47} while (0) 48 49 50FILE *set_binary_mode(FILE *stream) { 51 (void)stream; 52#if defined(_WIN32) || defined(__OS2__) 53 _setmode(_fileno(stream), _O_BINARY); 54#endif 55 return stream; 56} 57 58void die(const char *fmt, ...) { 59 LOG_ERROR(NULL); 60 usage_exit(); 61} 62 63void fatal(const char *fmt, ...) { 64 LOG_ERROR("Fatal"); 65 exit(EXIT_FAILURE); 66} 67 68void warn(const char *fmt, ...) { 69 LOG_ERROR("Warning"); 70} 71 72void die_codec(vpx_codec_ctx_t *ctx, const char *s) { 73 const char *detail = vpx_codec_error_detail(ctx); 74 75 printf("%s: %s\n", s, vpx_codec_error(ctx)); 76 if (detail) 77 printf(" %s\n", detail); 78 exit(EXIT_FAILURE); 79} 80 81int read_yuv_frame(struct VpxInputContext *input_ctx, vpx_image_t *yuv_frame) { 82 FILE *f = input_ctx->file; 83 struct FileTypeDetectionBuffer *detect = &input_ctx->detect; 84 int plane = 0; 85 int shortread = 0; 86 87 for (plane = 0; plane < 3; ++plane) { 88 uint8_t *ptr; 89 const int w = (plane ? (1 + yuv_frame->d_w) / 2 : yuv_frame->d_w); 90 const int h = (plane ? (1 + yuv_frame->d_h) / 2 : yuv_frame->d_h); 91 int r; 92 93 /* Determine the correct plane based on the image format. The for-loop 94 * always counts in Y,U,V order, but this may not match the order of 95 * the data on disk. 96 */ 97 switch (plane) { 98 case 1: 99 ptr = yuv_frame->planes[ 100 yuv_frame->fmt == VPX_IMG_FMT_YV12 ? VPX_PLANE_V : VPX_PLANE_U]; 101 break; 102 case 2: 103 ptr = yuv_frame->planes[ 104 yuv_frame->fmt == VPX_IMG_FMT_YV12 ? VPX_PLANE_U : VPX_PLANE_V]; 105 break; 106 default: 107 ptr = yuv_frame->planes[plane]; 108 } 109 110 for (r = 0; r < h; ++r) { 111 size_t needed = w; 112 size_t buf_position = 0; 113 const size_t left = detect->buf_read - detect->position; 114 if (left > 0) { 115 const size_t more = (left < needed) ? left : needed; 116 memcpy(ptr, detect->buf + detect->position, more); 117 buf_position = more; 118 needed -= more; 119 detect->position += more; 120 } 121 if (needed > 0) { 122 shortread |= (fread(ptr + buf_position, 1, needed, f) < needed); 123 } 124 125 ptr += yuv_frame->stride[plane]; 126 } 127 } 128 129 return shortread; 130} 131 132static const VpxInterface vpx_encoders[] = { 133#if CONFIG_VP8_ENCODER 134 {"vp8", VP8_FOURCC, &vpx_codec_vp8_cx}, 135#endif 136 137#if CONFIG_VP9_ENCODER 138 {"vp9", VP9_FOURCC, &vpx_codec_vp9_cx}, 139#endif 140}; 141 142int get_vpx_encoder_count() { 143 return sizeof(vpx_encoders) / sizeof(vpx_encoders[0]); 144} 145 146const VpxInterface *get_vpx_encoder_by_index(int i) { 147 return &vpx_encoders[i]; 148} 149 150const VpxInterface *get_vpx_encoder_by_name(const char *name) { 151 int i; 152 153 for (i = 0; i < get_vpx_encoder_count(); ++i) { 154 const VpxInterface *encoder = get_vpx_encoder_by_index(i); 155 if (strcmp(encoder->name, name) == 0) 156 return encoder; 157 } 158 159 return NULL; 160} 161 162static const VpxInterface vpx_decoders[] = { 163#if CONFIG_VP8_DECODER 164 {"vp8", VP8_FOURCC, &vpx_codec_vp8_dx}, 165#endif 166 167#if CONFIG_VP9_DECODER 168 {"vp9", VP9_FOURCC, &vpx_codec_vp9_dx}, 169#endif 170}; 171 172int get_vpx_decoder_count() { 173 return sizeof(vpx_decoders) / sizeof(vpx_decoders[0]); 174} 175 176const VpxInterface *get_vpx_decoder_by_index(int i) { 177 return &vpx_decoders[i]; 178} 179 180const VpxInterface *get_vpx_decoder_by_name(const char *name) { 181 int i; 182 183 for (i = 0; i < get_vpx_decoder_count(); ++i) { 184 const VpxInterface *const decoder = get_vpx_decoder_by_index(i); 185 if (strcmp(decoder->name, name) == 0) 186 return decoder; 187 } 188 189 return NULL; 190} 191 192const VpxInterface *get_vpx_decoder_by_fourcc(uint32_t fourcc) { 193 int i; 194 195 for (i = 0; i < get_vpx_decoder_count(); ++i) { 196 const VpxInterface *const decoder = get_vpx_decoder_by_index(i); 197 if (decoder->fourcc == fourcc) 198 return decoder; 199 } 200 201 return NULL; 202} 203 204// TODO(dkovalev): move this function to vpx_image.{c, h}, so it will be part 205// of vpx_image_t support 206int vpx_img_plane_width(const vpx_image_t *img, int plane) { 207 if (plane > 0 && img->x_chroma_shift > 0) 208 return (img->d_w + 1) >> img->x_chroma_shift; 209 else 210 return img->d_w; 211} 212 213int vpx_img_plane_height(const vpx_image_t *img, int plane) { 214 if (plane > 0 && img->y_chroma_shift > 0) 215 return (img->d_h + 1) >> img->y_chroma_shift; 216 else 217 return img->d_h; 218} 219 220void vpx_img_write(const vpx_image_t *img, FILE *file) { 221 int plane; 222 223 for (plane = 0; plane < 3; ++plane) { 224 const unsigned char *buf = img->planes[plane]; 225 const int stride = img->stride[plane]; 226 const int w = vpx_img_plane_width(img, plane); 227 const int h = vpx_img_plane_height(img, plane); 228 int y; 229 230 for (y = 0; y < h; ++y) { 231 fwrite(buf, 1, w, file); 232 buf += stride; 233 } 234 } 235} 236 237int vpx_img_read(vpx_image_t *img, FILE *file) { 238 int plane; 239 240 for (plane = 0; plane < 3; ++plane) { 241 unsigned char *buf = img->planes[plane]; 242 const int stride = img->stride[plane]; 243 const int w = vpx_img_plane_width(img, plane); 244 const int h = vpx_img_plane_height(img, plane); 245 int y; 246 247 for (y = 0; y < h; ++y) { 248 if (fread(buf, 1, w, file) != w) 249 return 0; 250 buf += stride; 251 } 252 } 253 254 return 1; 255} 256 257// TODO(dkovalev) change sse_to_psnr signature: double -> int64_t 258double sse_to_psnr(double samples, double peak, double sse) { 259 static const double kMaxPSNR = 100.0; 260 261 if (sse > 0.0) { 262 const double psnr = 10.0 * log10(samples * peak * peak / sse); 263 return psnr > kMaxPSNR ? kMaxPSNR : psnr; 264 } else { 265 return kMaxPSNR; 266 } 267} 268