opencore/codecs_v2/audio/gsm_amr/amr_wb/dec/src/pvamrwbdecoder_basic_op_gcc_armv5.h

   1 /* ------------------------------------------------------------------
   2  * Copyright (C) 1998-2009 PacketVideo
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
  13  * express or implied.
  14  * See the License for the specific language governing permissions
  15  * and limitations under the License.
  16  * -------------------------------------------------------------------
  17  */
  18 /****************************************************************************************
  19 Portions of this file are derived from the following 3GPP standard:
  20
  21     3GPP TS 26.173
  22     ANSI-C code for the Adaptive Multi-Rate - Wideband (AMR-WB) speech codec
  23     Available from http://www.3gpp.org
  24
  25 (C) 2007, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC)
  26 Permission to distribute, modify and use this file under the standard license
  27 terms listed above has been obtained from the copyright holder.
  28 ****************************************************************************************/
  29 /*
  30 ------------------------------------------------------------------------------
  31
  32
  33
  34  Pathname: ./src/pvamrwbdecoder_basic_op_gcc_armv5.h
  35
  36 ------------------------------------------------------------------------------
  37  INCLUDE DESCRIPTION
  38
  39 ------------------------------------------------------------------------------
  40 */
  41
  42 #ifndef PVAMRWBDECODER_BASIC_OP_GCC_ARMV5_H
  43 #define PVAMRWBDECODER_BASIC_OP_GCC_ARMV5_H
  44
  45 #ifdef __cplusplus
  46 extern "C"
  47 {
  48 #endif
  49
  50
  51 #if (defined(PV_ARM_GCC_V5)||defined(PV_ARM_GCC_V4))
  52
  53     static inline int16 sub_int16(int16 var1, int16 var2)
  54     {
  55         register int32 L_var_out;
  56         register int32 L_var_aux;
  57         register int32 ra = (int32)var1;
  58         register int32 rb = (int32)var2;
  59
  60         asm volatile(
  61             "mov  %0, %2, lsl #16\n"
  62             "mov  %1, %3, lsl #16\n"
  63             "qsub %0, %0, %1\n"
  64             "mov  %0, %0, asr #16"
  65     : "=&r*i"(L_var_out),
  66             "=&r*i"(L_var_aux)
  67                     : "r"(ra),
  68                     "r"(rb));
  69
  70         return (int16)L_var_out;
  71
  72     }
  73
  74     static inline int16 add_int16(int16 var1, int16 var2)
  75 {
  76         register int32 L_var_out;
  77         register int32 L_var_aux;
  78         register int32 ra = (int32)var1;
  79         register int32 rb = (int32)var2;
  80
  81         asm volatile(
  82             "mov  %0, %2, lsl #16\n"
  83             "mov  %1, %3, lsl #16\n"
  84             "qadd %0, %0, %1\n"
  85             "mov  %0, %0, asr #16"
  86     : "=&r*i"(L_var_out),
  87             "=&r*i"(L_var_aux)
  88                     : "r"(ra),
  89                     "r"(rb));
  90
  91         return (int16)L_var_out;
  92
  93     }
  94
  95     static inline  int32 mul_32by16(int16 hi, int16 lo, int16 n)
  96 {
  97         register int32 H_32;
  98         register int32 L_32;
  99         register int32 ra = (int32)hi;
 100         register int32 rb = (int32)lo;
 101         register int32 rc = (int32)n;
 102
 103
 104         asm volatile(
 105             "smulbb %0, %2, %4\n"
 106             "smulbb %1, %3, %4\n"
 107             "add    %0, %0, %1, asr #15\n"
 108             "qadd   %0, %0, %0"
 109     : "=&r*i"(H_32),
 110             "=&r*i"(L_32)
 111                     : "r"(ra),
 112                     "r"(rb),
 113                     "r"(rc));
 114
 115         return H_32;
 116     }
 117
 118
 119     static inline int32 sub_int32(int32 L_var1, int32 L_var2)
 120 {
 121         register int32 L_var_out;
 122         register int32 ra = L_var1;
 123         register int32 rb = L_var2;
 124
 125         asm volatile(
 126             "qsub %0, %1, %2"
 127     : "=&r*i"(L_var_out)
 128                     : "r"(ra),
 129                     "r"(rb));
 130
 131         return L_var_out;
 132     }
 133
 134     static inline int32 add_int32(int32 L_var1, int32 L_var2)
 135 {
 136         register int32 L_var_out;
 137         register int32 ra = L_var1;
 138         register int32 rb = L_var2;
 139
 140         asm volatile(
 141             "qadd %0, %1, %2"
 142     : "=&r*i"(L_var_out)
 143                     : "r"(ra),
 144                     "r"(rb));
 145
 146         return L_var_out;
 147     }
 148
 149     static inline int32 msu_16by16_from_int32(int32 L_var3, int16 var1, int16 var2)
 150 {
 151         register int32 L_var_out;
 152         register int32 ra = (int32)var1;
 153         register int32 rb = (int32)var2;
 154         register int32 rc = L_var3;
 155
 156         asm volatile(
 157             "smulbb %0, %1, %2\n"
 158             "qdsub %0, %3, %0"
 159     : "=&r*i"(L_var_out)
 160                     : "r"(ra),
 161                     "r"(rb),
 162                     "r"(rc));
 163
 164         return L_var_out;
 165     }
 166
 167
 168     static inline int32 mac_16by16_to_int32(int32 L_var3, int16 var1, int16 var2)
 169 {
 170         register int32 L_var_out;
 171         register int32 ra = (int32)var1;
 172         register int32 rb = (int32)var2;
 173         register int32 rc = L_var3;
 174
 175         asm volatile(
 176             "smulbb %0, %1, %2\n"
 177             "qdadd %0, %3, %0"
 178     : "=&r*i"(L_var_out)
 179                     : "r"(ra),
 180                     "r"(rb),
 181                     "r"(rc));
 182
 183         return L_var_out;
 184     }
 185
 186
 187     static inline  int32 mul_16by16_to_int32(int16 var1, int16 var2)
 188 {
 189         register int32 L_var_out;
 190         register int32 ra = (int32)var1;
 191         register int32 rb = (int32)var2;
 192
 193         asm volatile(
 194             "smulbb %0, %1, %2\n"
 195             "qadd %0, %0, %0"
 196     : "=&r*i"(L_var_out)
 197                     : "r"(ra),
 198                     "r"(rb));
 199
 200         return L_var_out;
 201     }
 202
 203
 204     static inline int16 mult_int16(int16 var1, int16 var2)
 205 {
 206         register int32 L_var_out;
 207         register int32 ra = (int32)var1;
 208         register int32 rb = (int32)var2;
 209
 210         asm volatile(
 211             "smulbb %0, %1, %2\n"
 212             "mov %0, %0, asr #15"
 213     : "=&r*i"(L_var_out)
 214                     : "r"(ra),
 215                     "r"(rb));
 216
 217         return (int16)L_var_out;
 218     }
 219
 220     static inline int16 amr_wb_round(int32 L_var1)
 221 {
 222         register int32 L_var_out;
 223         register int32 ra = (int32)L_var1;
 224         register int32 rb = (int32)0x00008000L;
 225
 226         asm volatile(
 227             "qadd %0, %1, %2\n"
 228             "mov %0, %0, asr #16"
 229     : "=&r*i"(L_var_out)
 230                     : "r"(ra),
 231                     "r"(rb));
 232         return (int16)L_var_out;
 233     }
 234
 235     static inline int16 amr_wb_shl1_round(int32 L_var1)
 236 {
 237         register int32 L_var_out;
 238         register int32 ra = (int32)L_var1;
 239         register int32 rb = (int32)0x00008000L;
 240
 241         asm volatile(
 242             "qadd %0, %1, %1\n"
 243             "qadd %0, %0, %2\n"
 244             "mov %0, %0, asr #16"
 245     : "=&r*i"(L_var_out)
 246                     : "r"(ra),
 247                     "r"(rb));
 248         return (int16)L_var_out;
 249     }
 250
 251
 252     static inline int32 fxp_mac_16by16(const int16 L_var1, const int16 L_var2, int32 L_add)
 253 {
 254         register int32 tmp;
 255         register int32 ra = (int32)L_var1;
 256         register int32 rb = (int32)L_var2;
 257         register int32 rc = (int32)L_add;
 258
 259         asm volatile(
 260             "smlabb %0, %1, %2, %3"
 261     : "=&r*i"(tmp)
 262                     : "r"(ra),
 263                     "r"(rb),
 264                     "r"(rc));
 265         return (tmp);
 266     }
 267
 268     static inline int32 fxp_mul_16by16bb(int16 L_var1, const int16 L_var2)
 269 {
 270         register int32 tmp;
 271         register int32 ra = (int32)L_var1;
 272         register int32 rb = (int32)L_var2;
 273
 274         asm volatile(
 275             "smulbb %0, %1, %2"
 276     : "=&r*i"(tmp)
 277                     : "r"(ra),
 278                     "r"(rb));
 279         return (tmp);
 280     }
 281
 282
 283 #define fxp_mul_16by16(a, b)  fxp_mul_16by16bb(  a, b)
 284
 285
 286     static inline int32 fxp_mul32_by_16(int32 L_var1, const int32 L_var2)
 287 {
 288         register int32 tmp;
 289         register int32 ra = (int32)L_var1;
 290         register int32 rb = (int32)L_var2;
 291
 292         asm volatile(
 293             "smulwb %0, %1, %2"
 294     : "=&r*i"(tmp)
 295                     : "r"(ra),
 296                     "r"(rb));
 297         return (tmp);
 298     }
 299
 300 #define fxp_mul32_by_16b( a, b)   fxp_mul32_by_16( a, b)
 301
 302
 303 #endif
 304
 305 #ifdef __cplusplus
 306 }
 307 #endif
 308
 309
 310
 311
 312 #endif   /*  PVAMRWBDECODER_BASIC_OP_GCC_ARMV5_H  */
 313