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 /**************************************************************************** 13 * 14 * Module Title : preproc.c 15 * 16 * Description : Simple pre-processor. 17 * 18 ****************************************************************************/ 19 20 /**************************************************************************** 21 * Header Files 22 ****************************************************************************/ 23 24 #include "memory.h" 25 #include "preproc7.h" 26 #include "vpx_mem/vpx_mem.h" 27 28 /**************************************************************************** 29 * Macros 30 ****************************************************************************/ 31 #define FRAMECOUNT 7 32 #define ROUNDUP32(X) ( ( ( (unsigned long) X ) + 31 )&( 0xFFFFFFE0 ) ) 33 34 /**************************************************************************** 35 * Imports 36 ****************************************************************************/ 37 extern void vp8_get_processor_flags(int *mmx_enabled, int *xmm_enabled, int *wmt_enabled); 38 39 /**************************************************************************** 40 * Exported Global Variables 41 ****************************************************************************/ 42 void (*temp_filter)(pre_proc_instance *ppi, unsigned char *s, unsigned char *d, int bytes, int strength); 43 void temp_filter_mmx 44 ( 45 pre_proc_instance *ppi, 46 unsigned char *s, 47 unsigned char *d, 48 int bytes, 49 int strength 50 ); 51 void temp_filter_wmt 52 ( 53 pre_proc_instance *ppi, 54 unsigned char *s, 55 unsigned char *d, 56 int bytes, 57 int strength 58 ); 59 60 /**************************************************************************** 61 * 62 * ROUTINE : temp_filter_c 63 * 64 * INPUTS : pre_proc_instance *ppi : Pointer to pre-processor instance. 65 * unsigned char *s : Pointer to source frame. 66 * unsigned char *d : Pointer to destination frame. 67 * int bytes : Number of bytes to filter. 68 * int strength : Strength of filter to apply. 69 * 70 * OUTPUTS : None. 71 * 72 * RETURNS : void 73 * 74 * FUNCTION : Performs a closesness adjusted temporarl blur 75 * 76 * SPECIAL NOTES : Destination frame can be same as source frame. 77 * 78 ****************************************************************************/ 79 void temp_filter_c 80 ( 81 pre_proc_instance *ppi, 82 unsigned char *s, 83 unsigned char *d, 84 int bytes, 85 int strength 86 ) 87 { 88 int byte = 0; 89 unsigned char *frameptr = ppi->frame_buffer; 90 91 if (ppi->frame == 0) 92 { 93 do 94 { 95 int frame = 0; 96 97 do 98 { 99 *frameptr = s[byte]; 100 ++frameptr; 101 ++frame; 102 } 103 while (frame < FRAMECOUNT); 104 105 d[byte] = s[byte]; 106 107 ++byte; 108 } 109 while (byte < bytes); 110 } 111 else 112 { 113 int modifier; 114 int offset = (ppi->frame % FRAMECOUNT); 115 116 do 117 { 118 int accumulator = 0; 119 int count = 0; 120 int frame = 0; 121 122 frameptr[offset] = s[byte]; 123 124 do 125 { 126 int pixel_value = *frameptr; 127 128 modifier = s[byte]; 129 modifier -= pixel_value; 130 modifier *= modifier; 131 modifier >>= strength; 132 modifier *= 3; 133 134 if (modifier > 16) 135 modifier = 16; 136 137 modifier = 16 - modifier; 138 139 accumulator += modifier * pixel_value; 140 141 count += modifier; 142 143 frameptr++; 144 145 ++frame; 146 } 147 while (frame < FRAMECOUNT); 148 149 accumulator += (count >> 1); 150 accumulator *= ppi->fixed_divide[count]; 151 accumulator >>= 16; 152 153 d[byte] = accumulator; 154 155 ++byte; 156 } 157 while (byte < bytes); 158 } 159 160 ++ppi->frame; 161 } 162 /**************************************************************************** 163 * 164 * ROUTINE : delete_pre_proc 165 * 166 * INPUTS : pre_proc_instance *ppi : Pointer to pre-processor instance. 167 * 168 * OUTPUTS : None. 169 * 170 * RETURNS : void 171 * 172 * FUNCTION : Deletes a pre-processing instance. 173 * 174 * SPECIAL NOTES : None. 175 * 176 ****************************************************************************/ 177 void delete_pre_proc(pre_proc_instance *ppi) 178 { 179 if (ppi->frame_buffer_alloc) 180 vpx_free(ppi->frame_buffer_alloc); 181 182 ppi->frame_buffer_alloc = 0; 183 ppi->frame_buffer = 0; 184 185 if (ppi->fixed_divide_alloc) 186 vpx_free(ppi->fixed_divide_alloc); 187 188 ppi->fixed_divide_alloc = 0; 189 ppi->fixed_divide = 0; 190 } 191 192 /**************************************************************************** 193 * 194 * ROUTINE : init_pre_proc 195 * 196 * INPUTS : pre_proc_instance *ppi : Pointer to pre-processor instance. 197 * int frame_size : Number of bytes in one frame. 198 * 199 * OUTPUTS : None. 200 * 201 * RETURNS : int: 1 if successful, 0 if failed. 202 * 203 * FUNCTION : Initializes prepprocessor instance. 204 * 205 * SPECIAL NOTES : None. 206 * 207 ****************************************************************************/ 208 int init_pre_proc7(pre_proc_instance *ppi, int frame_size) 209 { 210 int i; 211 int mmx_enabled; 212 int xmm_enabled; 213 int wmt_enabled; 214 215 vp8_get_processor_flags(&mmx_enabled, &xmm_enabled, &wmt_enabled); 216 217 if (wmt_enabled) 218 temp_filter = temp_filter_wmt; 219 else if (mmx_enabled) 220 temp_filter = temp_filter_mmx; 221 else 222 temp_filter = temp_filter_c; 223 224 225 delete_pre_proc(ppi); 226 227 ppi->frame_buffer_alloc = vpx_malloc(32 + frame_size * FRAMECOUNT * sizeof(unsigned char)); 228 229 if (!ppi->frame_buffer_alloc) 230 { 231 delete_pre_proc(ppi); 232 return 0; 233 } 234 235 ppi->frame_buffer = (unsigned char *) ROUNDUP32(ppi->frame_buffer_alloc); 236 237 ppi->fixed_divide_alloc = vpx_malloc(32 + 255 * sizeof(unsigned int)); 238 239 if (!ppi->fixed_divide_alloc) 240 { 241 delete_pre_proc(ppi); 242 return 0; 243 } 244 245 ppi->fixed_divide = (unsigned int *) ROUNDUP32(ppi->fixed_divide_alloc); 246 247 for (i = 1; i < 255; i++) 248 ppi->fixed_divide[i] = 0x10000 / i; 249 250 return 1; 251 } 252
