~ubuntu-branches/ubuntu/utopic/ffmpeg-debian/utopic

« back to all changes in this revision

Viewing changes to libavcodec/armv4l/mpegvideo_armv5te.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2009-01-20 09:20:53 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20090120092053-izz63p40hc98qfgp
Tags: 3:0.svn20090119-1ubuntu1
* merge from debian. LP: #318501
* new version fixes CVE-2008-3230, LP: #253767

Show diffs side-by-side

added added

removed removed

Lines of Context:
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 "libavcodec/avcodec.h"
23
 
#include "libavcodec/dsputil.h"
24
 
#include "libavcodec/mpegvideo.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
 
}