libavcodec/armv4l/mpegvideo_armv5te.c

   1 /*
   2  * Optimization of some functions from mpegvideo.c for armv5te
   3  * Copyright (c) 2007 Siarhei Siamashka <ssvb@users.sourceforge.net>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "dsputil.h"
  23 #include "mpegvideo.h"
  24 #include "avcodec.h"
  25
  26
  27 #ifdef ENABLE_ARM_TESTS
  28 /**
  29  * h263 dequantizer supplementary function, it is performance critical and needs to
  30  * have optimized implementations for each architecture. Is also used as a reference
  31  * implementation in regression tests
  32  */
  33 static inline void dct_unquantize_h263_helper_c(DCTELEM *block, int qmul, int qadd, int count)
  34 {
  35     int i, level;
  36     for (i = 0; i < count; i++) {
  37         level = block[i];
  38         if (level) {
  39             if (level < 0) {
  40                 level = level * qmul - qadd;
  41             } else {
  42                 level = level * qmul + qadd;
  43             }
  44             block[i] = level;
  45         }
  46     }
  47 }
  48 #endif
  49
  50 /* GCC 3.1 or higher is required to support symbolic names in assembly code */
  51 #if (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
  52
  53 /**
  54  * Special optimized version of dct_unquantize_h263_helper_c, it requires the block
  55  * to be at least 8 bytes aligned, and may process more elements than requested.
  56  * But it is guaranteed to never process more than 64 elements provided that
  57  * xxcount argument is <= 64, so it is safe. This macro is optimized for a common
  58  * distribution of values for nCoeffs (they are mostly multiple of 8 plus one or
  59  * two extra elements). So this macro processes data as 8 elements per loop iteration
  60  * and contains optional 2 elements processing in the end.
  61  *
  62  * Inner loop should take 6 cycles per element on arm926ej-s (Nokia 770)
  63  */
  64 #define dct_unquantize_h263_special_helper_armv5te(xxblock, xxqmul, xxqadd, xxcount) \
  65 ({ DCTELEM *xblock = xxblock; \
  66    int xqmul = xxqmul, xqadd = xxqadd, xcount = xxcount, xtmp; \
  67    int xdata1, xdata2; \
  68 asm volatile( \
  69         "subs %[count], %[count], #2       \n\t" \
  70         "ble 2f                            \n\t" \
  71         "ldrd r4, [%[block], #0]           \n\t" \
  72         "1:                                \n\t" \
  73         "ldrd r6, [%[block], #8]           \n\t" \
  74 \
  75         "rsbs %[data1], %[zero], r4, asr #16 \n\t" \
  76         "addgt %[data1], %[qadd], #0       \n\t" \
  77         "rsblt %[data1], %[qadd], #0       \n\t" \
  78         "smlatbne %[data1], r4, %[qmul], %[data1] \n\t" \
  79 \
  80         "rsbs %[data2], %[zero], r5, asr #16 \n\t" \
  81         "addgt %[data2], %[qadd], #0       \n\t" \
  82         "rsblt %[data2], %[qadd], #0       \n\t" \
  83         "smlatbne %[data2], r5, %[qmul], %[data2] \n\t" \
  84 \
  85         "rsbs %[tmp], %[zero], r4, asl #16 \n\t" \
  86         "addgt %[tmp], %[qadd], #0         \n\t" \
  87         "rsblt %[tmp], %[qadd], #0         \n\t" \
  88         "smlabbne r4, r4, %[qmul], %[tmp]  \n\t" \
  89 \
  90         "rsbs %[tmp], %[zero], r5, asl #16 \n\t" \
  91         "addgt %[tmp], %[qadd], #0         \n\t" \
  92         "rsblt %[tmp], %[qadd], #0         \n\t" \
  93         "smlabbne r5, r5, %[qmul], %[tmp]  \n\t" \
  94 \
  95         "strh r4, [%[block]], #2           \n\t" \
  96         "strh %[data1], [%[block]], #2     \n\t" \
  97         "strh r5, [%[block]], #2           \n\t" \
  98         "strh %[data2], [%[block]], #2     \n\t" \
  99 \
 100         "rsbs %[data1], %[zero], r6, asr #16 \n\t" \
 101         "addgt %[data1], %[qadd], #0        \n\t" \
 102         "rsblt %[data1], %[qadd], #0        \n\t" \
 103         "smlatbne %[data1], r6, %[qmul], %[data1] \n\t" \
 104 \
 105         "rsbs %[data2], %[zero], r7, asr #16 \n\t" \
 106         "addgt %[data2], %[qadd], #0        \n\t" \
 107         "rsblt %[data2], %[qadd], #0        \n\t" \
 108         "smlatbne %[data2], r7, %[qmul], %[data2] \n\t" \
 109 \
 110         "rsbs %[tmp], %[zero], r6, asl #16  \n\t" \
 111         "addgt %[tmp], %[qadd], #0          \n\t" \
 112         "rsblt %[tmp], %[qadd], #0          \n\t" \
 113         "smlabbne r6, r6, %[qmul], %[tmp]   \n\t" \
 114 \
 115         "rsbs %[tmp], %[zero], r7, asl #16  \n\t" \
 116         "addgt %[tmp], %[qadd], #0          \n\t" \
 117         "rsblt %[tmp], %[qadd], #0          \n\t" \
 118         "smlabbne r7, r7, %[qmul], %[tmp]   \n\t" \
 119 \
 120         "strh r6, [%[block]], #2            \n\t" \
 121         "strh %[data1], [%[block]], #2      \n\t" \
 122         "strh r7, [%[block]], #2            \n\t" \
 123         "strh %[data2], [%[block]], #2      \n\t" \
 124 \
 125         "subs %[count], %[count], #8        \n\t" \
 126         "ldrgtd r4, [%[block], #0]          \n\t" /* load data early to avoid load/use pipeline stall */ \
 127         "bgt 1b                             \n\t" \
 128 \
 129         "adds %[count], %[count], #2        \n\t" \
 130         "ble  3f                            \n\t" \
 131         "2:                                 \n\t" \
 132         "ldrsh %[data1], [%[block], #0]     \n\t" \
 133         "ldrsh %[data2], [%[block], #2]     \n\t" \
 134         "mov  %[tmp], %[qadd]               \n\t" \
 135         "cmp  %[data1], #0                  \n\t" \
 136         "rsblt %[tmp], %[qadd], #0          \n\t" \
 137         "smlabbne %[data1], %[data1], %[qmul], %[tmp] \n\t" \
 138         "mov  %[tmp], %[qadd]               \n\t" \
 139         "cmp  %[data2], #0                  \n\t" \
 140         "rsblt %[tmp], %[qadd], #0          \n\t" \
 141         "smlabbne %[data2], %[data2], %[qmul], %[tmp] \n\t" \
 142         "strh %[data1], [%[block]], #2      \n\t" \
 143         "strh %[data2], [%[block]], #2      \n\t" \
 144         "3:                                 \n\t" \
 145         : [block] "+&r" (xblock), [count] "+&r" (xcount), [tmp] "=&r" (xtmp), \
 146           [data1] "=&r" (xdata1), [data2] "=&r" (xdata2)  \
 147         : [qmul] "r" (xqmul), [qadd] "r" (xqadd), [zero] "r" (0) \
 148         : "r4", "r5", "r6", "r7", "cc", "memory" \
 149 ); \
 150 })
 151
 152 static void dct_unquantize_h263_intra_armv5te(MpegEncContext *s,
 153                                   DCTELEM *block, int n, int qscale)
 154 {
 155     int level, qmul, qadd;
 156     int nCoeffs;
 157
 158     assert(s->block_last_index[n]>=0);
 159
 160     qmul = qscale << 1;
 161
 162     if (!s->h263_aic) {
 163         if (n < 4)
 164             level = block[0] * s->y_dc_scale;
 165         else
 166             level = block[0] * s->c_dc_scale;
 167         qadd = (qscale - 1) | 1;
 168     }else{
 169         qadd = 0;
 170         level = block[0];
 171     }
 172     if(s->ac_pred)
 173         nCoeffs=63;
 174     else
 175         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
 176
 177     dct_unquantize_h263_special_helper_armv5te(block, qmul, qadd, nCoeffs + 1);
 178     block[0] = level;
 179 }
 180
 181 static void dct_unquantize_h263_inter_armv5te(MpegEncContext *s,
 182                                   DCTELEM *block, int n, int qscale)
 183 {
 184     int qmul, qadd;
 185     int nCoeffs;
 186
 187     assert(s->block_last_index[n]>=0);
 188
 189     qadd = (qscale - 1) | 1;
 190     qmul = qscale << 1;
 191
 192     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
 193
 194     dct_unquantize_h263_special_helper_armv5te(block, qmul, qadd, nCoeffs + 1);
 195 }
 196
 197 #define HAVE_DCT_UNQUANTIZE_H263_ARMV5TE_OPTIMIZED
 198
 199 #endif
 200
 201 void MPV_common_init_armv5te(MpegEncContext *s)
 202 {
 203 #ifdef HAVE_DCT_UNQUANTIZE_H263_ARMV5TE_OPTIMIZED
 204     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_armv5te;
 205     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_armv5te;
 206 #endif
 207 }