The Tor Browser / annotate

media/libopus/silk/resampler_private_down_FIR.c@ac0c01689b40 (annotated)

media/libopus/silk/resampler_private_down_FIR.c

Thu, 15 Jan 2015 15:59:08 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Thu, 15 Jan 2015 15:59:08 +0100
branch
TOR_BUG_9701
changeset 10
ac0c01689b40
permissions
-rw-r--r--

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

michael@0 1 /***********************************************************************
michael@0 2 Copyright (c) 2006-2011, Skype Limited. All rights reserved.
michael@0 3 Redistribution and use in source and binary forms, with or without
michael@0 4 modification, are permitted provided that the following conditions
michael@0 5 are met:
michael@0 6 - Redistributions of source code must retain the above copyright notice,
michael@0 7 this list of conditions and the following disclaimer.
michael@0 8 - Redistributions in binary form must reproduce the above copyright
michael@0 9 notice, this list of conditions and the following disclaimer in the
michael@0 10 documentation and/or other materials provided with the distribution.
michael@0 11 - Neither the name of Internet Society, IETF or IETF Trust, nor the
michael@0 12 names of specific contributors, may be used to endorse or promote
michael@0 13 products derived from this software without specific prior written
michael@0 14 permission.
michael@0 15 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
michael@0 16 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
michael@0 17 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
michael@0 18 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
michael@0 19 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
michael@0 20 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
michael@0 21 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
michael@0 22 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
michael@0 23 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
michael@0 24 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
michael@0 25 POSSIBILITY OF SUCH DAMAGE.
michael@0 26 ***********************************************************************/
michael@0 27
michael@0 28 #ifdef HAVE_CONFIG_H
michael@0 29 #include "config.h"
michael@0 30 #endif
michael@0 31
michael@0 32 #include "SigProc_FIX.h"
michael@0 33 #include "resampler_private.h"
michael@0 34 #include "stack_alloc.h"
michael@0 35
michael@0 36 static OPUS_INLINE opus_int16 *silk_resampler_private_down_FIR_INTERPOL(
michael@0 37 opus_int16 *out,
michael@0 38 opus_int32 *buf,
michael@0 39 const opus_int16 *FIR_Coefs,
michael@0 40 opus_int FIR_Order,
michael@0 41 opus_int FIR_Fracs,
michael@0 42 opus_int32 max_index_Q16,
michael@0 43 opus_int32 index_increment_Q16
michael@0 44 )
michael@0 45 {
michael@0 46 opus_int32 index_Q16, res_Q6;
michael@0 47 opus_int32 *buf_ptr;
michael@0 48 opus_int32 interpol_ind;
michael@0 49 const opus_int16 *interpol_ptr;
michael@0 50
michael@0 51 switch( FIR_Order ) {
michael@0 52 case RESAMPLER_DOWN_ORDER_FIR0:
michael@0 53 for( index_Q16 = 0; index_Q16 < max_index_Q16; index_Q16 += index_increment_Q16 ) {
michael@0 54 /* Integer part gives pointer to buffered input */
michael@0 55 buf_ptr = buf + silk_RSHIFT( index_Q16, 16 );
michael@0 56
michael@0 57 /* Fractional part gives interpolation coefficients */
michael@0 58 interpol_ind = silk_SMULWB( index_Q16 & 0xFFFF, FIR_Fracs );
michael@0 59
michael@0 60 /* Inner product */
michael@0 61 interpol_ptr = &FIR_Coefs[ RESAMPLER_DOWN_ORDER_FIR0 / 2 * interpol_ind ];
michael@0 62 res_Q6 = silk_SMULWB( buf_ptr[ 0 ], interpol_ptr[ 0 ] );
michael@0 63 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 1 ], interpol_ptr[ 1 ] );
michael@0 64 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 2 ], interpol_ptr[ 2 ] );
michael@0 65 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 3 ], interpol_ptr[ 3 ] );
michael@0 66 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 4 ], interpol_ptr[ 4 ] );
michael@0 67 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 5 ], interpol_ptr[ 5 ] );
michael@0 68 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 6 ], interpol_ptr[ 6 ] );
michael@0 69 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 7 ], interpol_ptr[ 7 ] );
michael@0 70 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 8 ], interpol_ptr[ 8 ] );
michael@0 71 interpol_ptr = &FIR_Coefs[ RESAMPLER_DOWN_ORDER_FIR0 / 2 * ( FIR_Fracs - 1 - interpol_ind ) ];
michael@0 72 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 17 ], interpol_ptr[ 0 ] );
michael@0 73 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 16 ], interpol_ptr[ 1 ] );
michael@0 74 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 15 ], interpol_ptr[ 2 ] );
michael@0 75 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 14 ], interpol_ptr[ 3 ] );
michael@0 76 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 13 ], interpol_ptr[ 4 ] );
michael@0 77 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 12 ], interpol_ptr[ 5 ] );
michael@0 78 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 11 ], interpol_ptr[ 6 ] );
michael@0 79 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 10 ], interpol_ptr[ 7 ] );
michael@0 80 res_Q6 = silk_SMLAWB( res_Q6, buf_ptr[ 9 ], interpol_ptr[ 8 ] );
michael@0 81
michael@0 82 /* Scale down, saturate and store in output array */
michael@0 83 *out++ = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( res_Q6, 6 ) );
michael@0 84 }
michael@0 85 break;
michael@0 86 case RESAMPLER_DOWN_ORDER_FIR1:
michael@0 87 for( index_Q16 = 0; index_Q16 < max_index_Q16; index_Q16 += index_increment_Q16 ) {
michael@0 88 /* Integer part gives pointer to buffered input */
michael@0 89 buf_ptr = buf + silk_RSHIFT( index_Q16, 16 );
michael@0 90
michael@0 91 /* Inner product */
michael@0 92 res_Q6 = silk_SMULWB( silk_ADD32( buf_ptr[ 0 ], buf_ptr[ 23 ] ), FIR_Coefs[ 0 ] );
michael@0 93 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 1 ], buf_ptr[ 22 ] ), FIR_Coefs[ 1 ] );
michael@0 94 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 2 ], buf_ptr[ 21 ] ), FIR_Coefs[ 2 ] );
michael@0 95 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 3 ], buf_ptr[ 20 ] ), FIR_Coefs[ 3 ] );
michael@0 96 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 4 ], buf_ptr[ 19 ] ), FIR_Coefs[ 4 ] );
michael@0 97 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 5 ], buf_ptr[ 18 ] ), FIR_Coefs[ 5 ] );
michael@0 98 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 6 ], buf_ptr[ 17 ] ), FIR_Coefs[ 6 ] );
michael@0 99 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 7 ], buf_ptr[ 16 ] ), FIR_Coefs[ 7 ] );
michael@0 100 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 8 ], buf_ptr[ 15 ] ), FIR_Coefs[ 8 ] );
michael@0 101 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 9 ], buf_ptr[ 14 ] ), FIR_Coefs[ 9 ] );
michael@0 102 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 10 ], buf_ptr[ 13 ] ), FIR_Coefs[ 10 ] );
michael@0 103 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 11 ], buf_ptr[ 12 ] ), FIR_Coefs[ 11 ] );
michael@0 104
michael@0 105 /* Scale down, saturate and store in output array */
michael@0 106 *out++ = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( res_Q6, 6 ) );
michael@0 107 }
michael@0 108 break;
michael@0 109 case RESAMPLER_DOWN_ORDER_FIR2:
michael@0 110 for( index_Q16 = 0; index_Q16 < max_index_Q16; index_Q16 += index_increment_Q16 ) {
michael@0 111 /* Integer part gives pointer to buffered input */
michael@0 112 buf_ptr = buf + silk_RSHIFT( index_Q16, 16 );
michael@0 113
michael@0 114 /* Inner product */
michael@0 115 res_Q6 = silk_SMULWB( silk_ADD32( buf_ptr[ 0 ], buf_ptr[ 35 ] ), FIR_Coefs[ 0 ] );
michael@0 116 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 1 ], buf_ptr[ 34 ] ), FIR_Coefs[ 1 ] );
michael@0 117 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 2 ], buf_ptr[ 33 ] ), FIR_Coefs[ 2 ] );
michael@0 118 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 3 ], buf_ptr[ 32 ] ), FIR_Coefs[ 3 ] );
michael@0 119 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 4 ], buf_ptr[ 31 ] ), FIR_Coefs[ 4 ] );
michael@0 120 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 5 ], buf_ptr[ 30 ] ), FIR_Coefs[ 5 ] );
michael@0 121 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 6 ], buf_ptr[ 29 ] ), FIR_Coefs[ 6 ] );
michael@0 122 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 7 ], buf_ptr[ 28 ] ), FIR_Coefs[ 7 ] );
michael@0 123 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 8 ], buf_ptr[ 27 ] ), FIR_Coefs[ 8 ] );
michael@0 124 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 9 ], buf_ptr[ 26 ] ), FIR_Coefs[ 9 ] );
michael@0 125 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 10 ], buf_ptr[ 25 ] ), FIR_Coefs[ 10 ] );
michael@0 126 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 11 ], buf_ptr[ 24 ] ), FIR_Coefs[ 11 ] );
michael@0 127 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 12 ], buf_ptr[ 23 ] ), FIR_Coefs[ 12 ] );
michael@0 128 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 13 ], buf_ptr[ 22 ] ), FIR_Coefs[ 13 ] );
michael@0 129 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 14 ], buf_ptr[ 21 ] ), FIR_Coefs[ 14 ] );
michael@0 130 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 15 ], buf_ptr[ 20 ] ), FIR_Coefs[ 15 ] );
michael@0 131 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 16 ], buf_ptr[ 19 ] ), FIR_Coefs[ 16 ] );
michael@0 132 res_Q6 = silk_SMLAWB( res_Q6, silk_ADD32( buf_ptr[ 17 ], buf_ptr[ 18 ] ), FIR_Coefs[ 17 ] );
michael@0 133
michael@0 134 /* Scale down, saturate and store in output array */
michael@0 135 *out++ = (opus_int16)silk_SAT16( silk_RSHIFT_ROUND( res_Q6, 6 ) );
michael@0 136 }
michael@0 137 break;
michael@0 138 default:
michael@0 139 silk_assert( 0 );
michael@0 140 }
michael@0 141 return out;
michael@0 142 }
michael@0 143
michael@0 144 /* Resample with a 2nd order AR filter followed by FIR interpolation */
michael@0 145 void silk_resampler_private_down_FIR(
michael@0 146 void *SS, /* I/O Resampler state */
michael@0 147 opus_int16 out[], /* O Output signal */
michael@0 148 const opus_int16 in[], /* I Input signal */
michael@0 149 opus_int32 inLen /* I Number of input samples */
michael@0 150 )
michael@0 151 {
michael@0 152 silk_resampler_state_struct *S = (silk_resampler_state_struct *)SS;
michael@0 153 opus_int32 nSamplesIn;
michael@0 154 opus_int32 max_index_Q16, index_increment_Q16;
michael@0 155 VARDECL( opus_int32, buf );
michael@0 156 const opus_int16 *FIR_Coefs;
michael@0 157 SAVE_STACK;
michael@0 158
michael@0 159 ALLOC( buf, S->batchSize + S->FIR_Order, opus_int32 );
michael@0 160
michael@0 161 /* Copy buffered samples to start of buffer */
michael@0 162 silk_memcpy( buf, S->sFIR.i32, S->FIR_Order * sizeof( opus_int32 ) );
michael@0 163
michael@0 164 FIR_Coefs = &S->Coefs[ 2 ];
michael@0 165
michael@0 166 /* Iterate over blocks of frameSizeIn input samples */
michael@0 167 index_increment_Q16 = S->invRatio_Q16;
michael@0 168 while( 1 ) {
michael@0 169 nSamplesIn = silk_min( inLen, S->batchSize );
michael@0 170
michael@0 171 /* Second-order AR filter (output in Q8) */
michael@0 172 silk_resampler_private_AR2( S->sIIR, &buf[ S->FIR_Order ], in, S->Coefs, nSamplesIn );
michael@0 173
michael@0 174 max_index_Q16 = silk_LSHIFT32( nSamplesIn, 16 );
michael@0 175
michael@0 176 /* Interpolate filtered signal */
michael@0 177 out = silk_resampler_private_down_FIR_INTERPOL( out, buf, FIR_Coefs, S->FIR_Order,
michael@0 178 S->FIR_Fracs, max_index_Q16, index_increment_Q16 );
michael@0 179
michael@0 180 in += nSamplesIn;
michael@0 181 inLen -= nSamplesIn;
michael@0 182
michael@0 183 if( inLen > 1 ) {
michael@0 184 /* More iterations to do; copy last part of filtered signal to beginning of buffer */
michael@0 185 silk_memcpy( buf, &buf[ nSamplesIn ], S->FIR_Order * sizeof( opus_int32 ) );
michael@0 186 } else {
michael@0 187 break;
michael@0 188 }
michael@0 189 }
michael@0 190
michael@0 191 /* Copy last part of filtered signal to the state for the next call */
michael@0 192 silk_memcpy( S->sFIR.i32, &buf[ nSamplesIn ], S->FIR_Order * sizeof( opus_int32 ) );
michael@0 193 RESTORE_STACK;
michael@0 194 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial