← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libav/trusty-proposed

« back to all changes in this revision

Viewing changes to libavcodec/svq3.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2013-10-22 23:24:08 UTC
  • mfrom: (1.3.36 sid)
  • Revision ID: package-import@ubuntu.com-20131022232408-b8tvvn4pyzri9mi3
Tags: 6:9.10-1ubuntu1
https://launchpad.net/bugs/1243235
https://launchpad.net/bugs/1180288
https://launchpad.net/bugs/1242802
* Build all -extra flavors from this source package, as libav got demoted
  from main to universe, cf LP: #1243235
* Simplify debian/rules to follow exactly the code that debian executes
* New upstream (LP: #1180288) fixes lots of security issues (LP: #1242802)
* Merge from unstable, remaining changes:
  - build-depend on libtiff5-dev rather than libtiff4-dev,
    avoids FTBFS caused by imlib
  - follow the regular debian codepaths

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/svq3.c
45
45
#include "mpegvideo.h"
46
46
#include "h264.h"
47
47
 
48
 
#include "h264data.h" //FIXME FIXME FIXME
 
48
#include "h264data.h" // FIXME FIXME FIXME
49
49
 
50
50
#include "h264_mvpred.h"
51
51
#include "golomb.h"
78
78
#define PREDICT_MODE  4
79
79
 
80
80
/* dual scan (from some older h264 draft)
81
 
 o-->o-->o   o
82
 
         |  /|
83
 
 o   o   o / o
84
 
 | / |   |/  |
85
 
 o   o   o   o
86
 
   /
87
 
 o-->o-->o-->o
88
 
*/
 
81
 * o-->o-->o   o
 
82
 *         |  /|
 
83
 * o   o   o / o
 
84
 * | / |   |/  |
 
85
 * o   o   o   o
 
86
 *   /
 
87
 * o-->o-->o-->o
 
88
 */
89
89
static const uint8_t svq3_scan[16] = {
90
 
    0+0*4, 1+0*4, 2+0*4, 2+1*4,
91
 
    2+2*4, 3+0*4, 3+1*4, 3+2*4,
92
 
    0+1*4, 0+2*4, 1+1*4, 1+2*4,
93
 
    0+3*4, 1+3*4, 2+3*4, 3+3*4,
 
90
    0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
 
91
    2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
 
92
    0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
 
93
    0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
94
94
};
95
95
 
96
96
static const uint8_t svq3_pred_0[25][2] = {
106
106
};
107
107
 
108
108
static const int8_t svq3_pred_1[6][6][5] = {
109
 
    { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
110
 
      { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
111
 
    { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
112
 
      { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
113
 
    { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
114
 
      { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
115
 
    { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
116
 
      { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
117
 
    { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
118
 
      { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
119
 
    { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
120
 
      { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
 
109
    { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
 
110
      { 2,  1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
 
111
    { { 0,  2, -1, -1, -1 }, { 0, 2,  1,  4,  3 }, { 0, 1,  2,  4,  3 },
 
112
      { 0,  2,  1,  4,  3 }, { 2, 0,  1,  3,  4 }, { 0, 4,  2,  1,  3 } },
 
113
    { { 2,  0, -1, -1, -1 }, { 2, 1,  0,  4,  3 }, { 1, 2,  4,  0,  3 },
 
114
      { 2,  1,  0,  4,  3 }, { 2, 1,  4,  3,  0 }, { 1, 2,  4,  0,  3 } },
 
115
    { { 2,  0, -1, -1, -1 }, { 2, 0,  1,  4,  3 }, { 1, 2,  0,  4,  3 },
 
116
      { 2,  1,  0,  4,  3 }, { 2, 1,  3,  4,  0 }, { 2, 4,  1,  0,  3 } },
 
117
    { { 0,  2, -1, -1, -1 }, { 0, 2,  1,  3,  4 }, { 1, 2,  3,  0,  4 },
 
118
      { 2,  0,  1,  3,  4 }, { 2, 1,  3,  0,  4 }, { 2, 0,  4,  3,  1 } },
 
119
    { { 0,  2, -1, -1, -1 }, { 0, 2,  4,  1,  3 }, { 1, 4,  2,  0,  3 },
 
120
      { 4,  2,  0,  1,  3 }, { 2, 0,  1,  4,  3 }, { 4, 2,  1,  0,  3 } },
121
121
};
122
122
 
123
 
static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
 
123
static const struct {
 
124
    uint8_t run;
 
125
    uint8_t level;
 
126
} svq3_dct_tables[2][16] = {
124
127
    { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
125
128
      { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
126
129
    { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
128
131
};
129
132
 
130
133
static const uint32_t svq3_dequant_coeff[32] = {
131
 
     3881,  4351,  4890,  5481,  6154,  6914,  7761,  8718,
132
 
     9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
133
 
    24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
134
 
    61694, 68745, 77615, 89113,100253,109366,126635,141533
 
134
     3881,  4351,  4890,  5481,   6154,   6914,   7761,   8718,
 
135
     9781, 10987, 12339, 13828,  15523,  17435,  19561,  21873,
 
136
    24552, 27656, 30847, 34870,  38807,  43747,  49103,  54683,
 
137
    61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
135
138
};
136
139
 
137
 
void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *output, DCTELEM *input, int qp){
 
140
void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *output, DCTELEM *input, int qp)
 
141
{
138
142
    const int qmul = svq3_dequant_coeff[qp];
139
143
#define stride 16
140
144
    int i;
141
145
    int temp[16];
142
 
    static const uint8_t x_offset[4]={0, 1*stride, 4*stride, 5*stride};
143
 
 
144
 
    for(i=0; i<4; i++){
145
 
        const int z0 = 13*(input[4*i+0] +    input[4*i+2]);
146
 
        const int z1 = 13*(input[4*i+0] -    input[4*i+2]);
147
 
        const int z2 =  7* input[4*i+1] - 17*input[4*i+3];
148
 
        const int z3 = 17* input[4*i+1] +  7*input[4*i+3];
149
 
 
150
 
        temp[4*i+0] = z0+z3;
151
 
        temp[4*i+1] = z1+z2;
152
 
        temp[4*i+2] = z1-z2;
153
 
        temp[4*i+3] = z0-z3;
 
146
    static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
 
147
 
 
148
    for (i = 0; i < 4; i++) {
 
149
        const int z0 = 13 * (input[4 * i + 0] +      input[4 * i + 2]);
 
150
        const int z1 = 13 * (input[4 * i + 0] -      input[4 * i + 2]);
 
151
        const int z2 =  7 *  input[4 * i + 1] - 17 * input[4 * i + 3];
 
152
        const int z3 = 17 *  input[4 * i + 1] +  7 * input[4 * i + 3];
 
153
 
 
154
        temp[4 * i + 0] = z0 + z3;
 
155
        temp[4 * i + 1] = z1 + z2;
 
156
        temp[4 * i + 2] = z1 - z2;
 
157
        temp[4 * i + 3] = z0 - z3;
154
158
    }
155
159
 
156
 
    for(i=0; i<4; i++){
157
 
        const int offset= x_offset[i];
158
 
        const int z0= 13*(temp[4*0+i] +    temp[4*2+i]);
159
 
        const int z1= 13*(temp[4*0+i] -    temp[4*2+i]);
160
 
        const int z2=  7* temp[4*1+i] - 17*temp[4*3+i];
161
 
        const int z3= 17* temp[4*1+i] +  7*temp[4*3+i];
 
160
    for (i = 0; i < 4; i++) {
 
161
        const int offset = x_offset[i];
 
162
        const int z0     = 13 * (temp[4 * 0 + i] +      temp[4 * 2 + i]);
 
163
        const int z1     = 13 * (temp[4 * 0 + i] -      temp[4 * 2 + i]);
 
164
        const int z2     =  7 *  temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
 
165
        const int z3     = 17 *  temp[4 * 1 + i] +  7 * temp[4 * 3 + i];
162
166
 
163
 
        output[stride* 0+offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
164
 
        output[stride* 2+offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
165
 
        output[stride* 8+offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
166
 
        output[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
 
167
        output[stride *  0 + offset] = (z0 + z3) * qmul + 0x80000 >> 20;
 
168
        output[stride *  2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
 
169
        output[stride *  8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
 
170
        output[stride * 10 + offset] = (z0 - z3) * qmul + 0x80000 >> 20;
167
171
    }
168
172
}
169
173
#undef stride
170
174
 
171
 
void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
172
 
                            int dc)
 
175
void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block,
 
176
                        int stride, int qp, int dc)
173
177
{
174
178
    const int qmul = svq3_dequant_coeff[qp];
175
179
    int i;
176
180
 
177
181
    if (dc) {
178
 
        dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
 
182
        dc       = 13 * 13 * (dc == 1 ? 1538 * block[0]
 
183
                                      : qmul * (block[0] >> 3) / 2);
179
184
        block[0] = 0;
180
185
    }
181
186
 
182
187
    for (i = 0; i < 4; i++) {
183
 
        const int z0 = 13*(block[0 + 4*i] +    block[2 + 4*i]);
184
 
        const int z1 = 13*(block[0 + 4*i] -    block[2 + 4*i]);
185
 
        const int z2 =  7* block[1 + 4*i] - 17*block[3 + 4*i];
186
 
        const int z3 = 17* block[1 + 4*i] +  7*block[3 + 4*i];
 
188
        const int z0 = 13 * (block[0 + 4 * i] +      block[2 + 4 * i]);
 
189
        const int z1 = 13 * (block[0 + 4 * i] -      block[2 + 4 * i]);
 
190
        const int z2 =  7 *  block[1 + 4 * i] - 17 * block[3 + 4 * i];
 
191
        const int z3 = 17 *  block[1 + 4 * i] +  7 * block[3 + 4 * i];
187
192
 
188
 
        block[0 + 4*i] = z0 + z3;
189
 
        block[1 + 4*i] = z1 + z2;
190
 
        block[2 + 4*i] = z1 - z2;
191
 
        block[3 + 4*i] = z0 - z3;
 
193
        block[0 + 4 * i] = z0 + z3;
 
194
        block[1 + 4 * i] = z1 + z2;
 
195
        block[2 + 4 * i] = z1 - z2;
 
196
        block[3 + 4 * i] = z0 - z3;
192
197
    }
193
198
 
194
199
    for (i = 0; i < 4; i++) {
195
 
        const int z0 = 13*(block[i + 4*0] +    block[i + 4*2]);
196
 
        const int z1 = 13*(block[i + 4*0] -    block[i + 4*2]);
197
 
        const int z2 =  7* block[i + 4*1] - 17*block[i + 4*3];
198
 
        const int z3 = 17* block[i + 4*1] +  7*block[i + 4*3];
 
200
        const int z0 = 13 * (block[i + 4 * 0] +      block[i + 4 * 2]);
 
201
        const int z1 = 13 * (block[i + 4 * 0] -      block[i + 4 * 2]);
 
202
        const int z2 =  7 *  block[i + 4 * 1] - 17 * block[i + 4 * 3];
 
203
        const int z3 = 17 *  block[i + 4 * 1] +  7 * block[i + 4 * 3];
199
204
        const int rr = (dc + 0x80000);
200
205
 
201
 
        dst[i + stride*0] = av_clip_uint8( dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) );
202
 
        dst[i + stride*1] = av_clip_uint8( dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) );
203
 
        dst[i + stride*2] = av_clip_uint8( dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) );
204
 
        dst[i + stride*3] = av_clip_uint8( dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) );
 
206
        dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
 
207
        dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
 
208
        dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
 
209
        dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((z0 - z3) * qmul + rr >> 20));
205
210
    }
206
211
}
207
212
 
211
216
    static const uint8_t *const scan_patterns[4] =
212
217
    { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
213
218
 
214
 
    int run, level, sign, vlc, limit;
215
 
    const int intra = (3 * type) >> 2;
 
219
    int run, level, limit;
 
220
    unsigned vlc;
 
221
    const int intra           = 3 * type >> 2;
216
222
    const uint8_t *const scan = scan_patterns[type];
217
223
 
218
224
    for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
219
225
        for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
220
 
 
221
 
          if (vlc == INVALID_VLC)
222
 
              return -1;
223
 
 
224
 
          sign = (vlc & 0x1) - 1;
225
 
          vlc  = (vlc + 1) >> 1;
226
 
 
227
 
          if (type == 3) {
228
 
              if (vlc < 3) {
229
 
                  run   = 0;
230
 
                  level = vlc;
231
 
              } else if (vlc < 4) {
232
 
                  run   = 1;
233
 
                  level = 1;
234
 
              } else {
235
 
                  run   = (vlc & 0x3);
236
 
                  level = ((vlc + 9) >> 2) - run;
237
 
              }
238
 
          } else {
239
 
              if (vlc < 16) {
240
 
                  run   = svq3_dct_tables[intra][vlc].run;
241
 
                  level = svq3_dct_tables[intra][vlc].level;
242
 
              } else if (intra) {
243
 
                  run   = (vlc & 0x7);
244
 
                  level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
245
 
              } else {
246
 
                  run   = (vlc & 0xF);
247
 
                  level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
248
 
              }
249
 
          }
250
 
 
251
 
          if ((index += run) >= limit)
252
 
              return -1;
253
 
 
254
 
          block[scan[index]] = (level ^ sign) - sign;
 
226
            int sign = (vlc & 1) ? 0 : -1;
 
227
            vlc      = vlc + 1 >> 1;
 
228
 
 
229
            if (type == 3) {
 
230
                if (vlc < 3) {
 
231
                    run   = 0;
 
232
                    level = vlc;
 
233
                } else if (vlc < 4) {
 
234
                    run   = 1;
 
235
                    level = 1;
 
236
                } else {
 
237
                    run   = vlc & 0x3;
 
238
                    level = (vlc + 9 >> 2) - run;
 
239
                }
 
240
            } else {
 
241
                if (vlc < 16) {
 
242
                    run   = svq3_dct_tables[intra][vlc].run;
 
243
                    level = svq3_dct_tables[intra][vlc].level;
 
244
                } else if (intra) {
 
245
                    run   = vlc & 0x7;
 
246
                    level = (vlc >> 3) +
 
247
                            ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
 
248
                } else {
 
249
                    run   = vlc & 0xF;
 
250
                    level = (vlc >> 4) +
 
251
                            ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
 
252
                }
 
253
            }
 
254
 
 
255
            if ((index += run) >= limit)
 
256
                return -1;
 
257
 
 
258
            block[scan[index]] = (level ^ sign) - sign;
255
259
        }
256
260
 
257
261
        if (type != 2) {
270
274
    const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
271
275
    uint8_t *src, *dest;
272
276
    int i, emu = 0;
273
 
    int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2
 
277
    int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
274
278
 
275
279
    mx += x;
276
280
    my += y;
277
281
 
278
 
    if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
279
 
        my < 0 || my >= (s->v_edge_pos - height - 1)) {
280
 
 
281
 
        if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
 
282
    if (mx < 0 || mx >= s->h_edge_pos - width  - 1 ||
 
283
        my < 0 || my >= s->v_edge_pos - height - 1) {
 
284
        if ((s->flags & CODEC_FLAG_EMU_EDGE))
282
285
            emu = 1;
283
 
        }
284
286
 
285
 
        mx = av_clip (mx, -16, (s->h_edge_pos - width  + 15));
286
 
        my = av_clip (my, -16, (s->v_edge_pos - height + 15));
 
287
        mx = av_clip(mx, -16, s->h_edge_pos - width  + 15);
 
288
        my = av_clip(my, -16, s->v_edge_pos - height + 15);
287
289
    }
288
290
 
289
291
    /* form component predictions */
290
 
    dest = s->current_picture.f.data[0] + x + y*s->linesize;
291
 
    src  = pic->f.data[0] + mx + my*s->linesize;
 
292
    dest = s->current_picture.f.data[0] + x + y * s->linesize;
 
293
    src  = pic->f.data[0] + mx + my * s->linesize;
292
294
 
293
295
    if (emu) {
294
 
        s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
295
 
                            mx, my, s->h_edge_pos, s->v_edge_pos);
 
296
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize,
 
297
                                 width + 1, height + 1,
 
298
                                 mx, my, s->h_edge_pos, s->v_edge_pos);
296
299
        src = s->edge_emu_buffer;
297
300
    }
298
301
    if (thirdpel)
299
 
        (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
 
302
        (avg ? s->dsp.avg_tpel_pixels_tab
 
303
             : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize,
 
304
                                                width, height);
300
305
    else
301
 
        (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
 
306
        (avg ? s->dsp.avg_pixels_tab
 
307
             : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize,
 
308
                                                      height);
302
309
 
303
310
    if (!(s->flags & CODEC_FLAG_GRAY)) {
304
 
        mx     = (mx + (mx < (int) x)) >> 1;
305
 
        my     = (my + (my < (int) y)) >> 1;
306
 
        width  = (width  >> 1);
307
 
        height = (height >> 1);
 
311
        mx     = mx + (mx < (int) x) >> 1;
 
312
        my     = my + (my < (int) y) >> 1;
 
313
        width  = width  >> 1;
 
314
        height = height >> 1;
308
315
        blocksize++;
309
316
 
310
317
        for (i = 1; i < 3; i++) {
312
319
            src  = pic->f.data[i] + mx + my * s->uvlinesize;
313
320
 
314
321
            if (emu) {
315
 
                s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
316
 
                                    mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
 
322
                s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize,
 
323
                                         width + 1, height + 1,
 
324
                                         mx, my, (s->h_edge_pos >> 1),
 
325
                                         s->v_edge_pos >> 1);
317
326
                src = s->edge_emu_buffer;
318
327
            }
319
328
            if (thirdpel)
320
 
                (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
 
329
                (avg ? s->dsp.avg_tpel_pixels_tab
 
330
                     : s->dsp.put_tpel_pixels_tab)[dxy](dest, src,
 
331
                                                        s->uvlinesize,
 
332
                                                        width, height);
321
333
            else
322
 
                (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
 
334
                (avg ? s->dsp.avg_pixels_tab
 
335
                     : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src,
 
336
                                                              s->uvlinesize,
 
337
                                                              height);
323
338
        }
324
339
    }
325
340
}
326
341
 
327
 
static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir,
328
 
                              int avg)
 
342
static inline int svq3_mc_dir(H264Context *h, int size, int mode,
 
343
                              int dir, int avg)
329
344
{
330
345
    int i, j, k, mx, my, dx, dy, x, y;
331
 
    MpegEncContext *const s = (MpegEncContext *) h;
332
 
    const int part_width  = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
333
 
    const int part_height = 16 >> ((unsigned) (size + 1) / 3);
334
 
    const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
335
 
    const int h_edge_pos  = 6*(s->h_edge_pos - part_width ) - extra_width;
336
 
    const int v_edge_pos  = 6*(s->v_edge_pos - part_height) - extra_width;
 
346
    MpegEncContext *const s = (MpegEncContext *)h;
 
347
    const int part_width    = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
 
348
    const int part_height   = 16 >> ((unsigned)(size + 1) / 3);
 
349
    const int extra_width   = (mode == PREDICT_MODE) ? -16 * 6 : 0;
 
350
    const int h_edge_pos    = 6 * (s->h_edge_pos - part_width)  - extra_width;
 
351
    const int v_edge_pos    = 6 * (s->v_edge_pos - part_height) - extra_width;
337
352
 
338
 
    for (i = 0; i < 16; i += part_height) {
 
353
    for (i = 0; i < 16; i += part_height)
339
354
        for (j = 0; j < 16; j += part_width) {
340
 
            const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride;
 
355
            const int b_xy = (4 * s->mb_x + (j >> 2)) +
 
356
                             (4 * s->mb_y + (i >> 2)) * h->b_stride;
341
357
            int dxy;
342
 
            x = 16*s->mb_x + j;
343
 
            y = 16*s->mb_y + i;
344
 
            k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8);
 
358
            x = 16 * s->mb_x + j;
 
359
            y = 16 * s->mb_y + i;
 
360
            k = (j >> 2 & 1) + (i >> 1 & 2) +
 
361
                (j >> 1 & 4) + (i      & 8);
345
362
 
346
363
            if (mode != PREDICT_MODE) {
347
 
                pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my);
 
364
                pred_motion(h, k, part_width >> 2, dir, 1, &mx, &my);
348
365
            } else {
349
366
                mx = s->next_picture.f.motion_val[0][b_xy][0] << 1;
350
367
                my = s->next_picture.f.motion_val[0][b_xy][1] << 1;
351
368
 
352
369
                if (dir == 0) {
353
 
                    mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
354
 
                    my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
 
370
                    mx = mx * h->frame_num_offset /
 
371
                         h->prev_frame_num_offset + 1 >> 1;
 
372
                    my = my * h->frame_num_offset /
 
373
                         h->prev_frame_num_offset + 1 >> 1;
355
374
                } else {
356
 
                    mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
357
 
                    my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
 
375
                    mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
 
376
                         h->prev_frame_num_offset + 1 >> 1;
 
377
                    my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
 
378
                         h->prev_frame_num_offset + 1 >> 1;
358
379
                }
359
380
            }
360
381
 
361
382
            /* clip motion vector prediction to frame border */
362
 
            mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
363
 
            my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
 
383
            mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
 
384
            my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
364
385
 
365
386
            /* get (optional) motion vector differential */
366
387
            if (mode == PREDICT_MODE) {
378
399
            /* compute motion vector */
379
400
            if (mode == THIRDPEL_MODE) {
380
401
                int fx, fy;
381
 
                mx  = ((mx + 1)>>1) + dx;
382
 
                my  = ((my + 1)>>1) + dy;
383
 
                fx  = ((unsigned)(mx + 0x3000))/3 - 0x1000;
384
 
                fy  = ((unsigned)(my + 0x3000))/3 - 0x1000;
385
 
                dxy = (mx - 3*fx) + 4*(my - 3*fy);
 
402
                mx  = (mx + 1 >> 1) + dx;
 
403
                my  = (my + 1 >> 1) + dy;
 
404
                fx  = (unsigned)(mx + 0x3000) / 3 - 0x1000;
 
405
                fy  = (unsigned)(my + 0x3000) / 3 - 0x1000;
 
406
                dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
386
407
 
387
 
                svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
 
408
                svq3_mc_dir_part(s, x, y, part_width, part_height,
 
409
                                 fx, fy, dxy, 1, dir, avg);
388
410
                mx += mx;
389
411
                my += my;
390
412
            } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
391
 
                mx  = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
392
 
                my  = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
393
 
                dxy = (mx&1) + 2*(my&1);
 
413
                mx  = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
 
414
                my  = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
 
415
                dxy = (mx & 1) + 2 * (my & 1);
394
416
 
395
 
                svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
 
417
                svq3_mc_dir_part(s, x, y, part_width, part_height,
 
418
                                 mx >> 1, my >> 1, dxy, 0, dir, avg);
396
419
                mx *= 3;
397
420
                my *= 3;
398
421
            } else {
399
 
                mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
400
 
                my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
 
422
                mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
 
423
                my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
401
424
 
402
 
                svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
 
425
                svq3_mc_dir_part(s, x, y, part_width, part_height,
 
426
                                 mx, my, 0, 0, dir, avg);
403
427
                mx *= 6;
404
428
                my *= 6;
405
429
            }
406
430
 
407
431
            /* update mv_cache */
408
432
            if (mode != PREDICT_MODE) {
409
 
                int32_t mv = pack16to32(mx,my);
 
433
                int32_t mv = pack16to32(mx, my);
410
434
 
411
435
                if (part_height == 8 && i < 8) {
412
 
                    AV_WN32A(h->mv_cache[dir][scan8[k] + 1*8], mv);
 
436
                    AV_WN32A(h->mv_cache[dir][scan8[k] + 1 * 8], mv);
413
437
 
414
 
                    if (part_width == 8 && j < 8) {
415
 
                        AV_WN32A(h->mv_cache[dir][scan8[k] + 1 + 1*8], mv);
416
 
                    }
 
438
                    if (part_width == 8 && j < 8)
 
439
                        AV_WN32A(h->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
417
440
                }
418
 
                if (part_width == 8 && j < 8) {
 
441
                if (part_width == 8 && j < 8)
419
442
                    AV_WN32A(h->mv_cache[dir][scan8[k] + 1], mv);
420
 
                }
421
 
                if (part_width == 4 || part_height == 4) {
 
443
                if (part_width == 4 || part_height == 4)
422
444
                    AV_WN32A(h->mv_cache[dir][scan8[k]], mv);
423
 
                }
424
445
            }
425
446
 
426
447
            /* write back motion vectors */
428
449
                           part_width >> 2, part_height >> 2, h->b_stride,
429
450
                           pack16to32(mx, my), 4);
430
451
        }
431
 
    }
432
452
 
433
453
    return 0;
434
454
}
440
460
    int cbp = 0;
441
461
    uint32_t vlc;
442
462
    int8_t *top, *left;
443
 
    MpegEncContext *const s = (MpegEncContext *) h;
444
 
    const int mb_xy = h->mb_xy;
445
 
    const int b_xy  = 4*s->mb_x + 4*s->mb_y*h->b_stride;
 
463
    MpegEncContext *const s = (MpegEncContext *)h;
 
464
    const int mb_xy         = h->mb_xy;
 
465
    const int b_xy          = 4 * s->mb_x + 4 * s->mb_y * h->b_stride;
446
466
 
447
467
    h->top_samples_available      = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
448
468
    h->left_samples_available     = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
449
469
    h->topright_samples_available = 0xFFFF;
450
470
 
451
471
    if (mb_type == 0) {           /* SKIP */
452
 
        if (s->pict_type == AV_PICTURE_TYPE_P || s->next_picture.f.mb_type[mb_xy] == -1) {
453
 
            svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
 
472
        if (s->pict_type == AV_PICTURE_TYPE_P ||
 
473
            s->next_picture.f.mb_type[mb_xy] == -1) {
 
474
            svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
 
475
                             0, 0, 0, 0, 0, 0);
454
476
 
455
 
            if (s->pict_type == AV_PICTURE_TYPE_B) {
456
 
                svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
457
 
            }
 
477
            if (s->pict_type == AV_PICTURE_TYPE_B)
 
478
                svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
 
479
                                 0, 0, 0, 0, 1, 1);
458
480
 
459
481
            mb_type = MB_TYPE_SKIP;
460
482
        } else {
467
489
            mb_type = MB_TYPE_16x16;
468
490
        }
469
491
    } else if (mb_type < 8) {     /* INTER */
470
 
        if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1 (&s->gb)) {
 
492
        if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1(&s->gb))
471
493
            mode = THIRDPEL_MODE;
472
 
        } else if (svq3->halfpel_flag && svq3->thirdpel_flag == !get_bits1 (&s->gb)) {
 
494
        else if (svq3->halfpel_flag &&
 
495
                 svq3->thirdpel_flag == !get_bits1(&s->gb))
473
496
            mode = HALFPEL_MODE;
474
 
        } else {
 
497
        else
475
498
            mode = FULLPEL_MODE;
476
 
        }
477
499
 
478
500
        /* fill caches */
479
501
        /* note ref_cache should contain here:
480
 
            ????????
481
 
            ???11111
482
 
            N??11111
483
 
            N??11111
484
 
            N??11111
485
 
        */
 
502
         *  ????????
 
503
         *  ???11111
 
504
         *  N??11111
 
505
         *  N??11111
 
506
         *  N??11111
 
507
         */
486
508
 
487
509
        for (m = 0; m < 2; m++) {
488
 
            if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6] != -1) {
489
 
                for (i = 0; i < 4; i++) {
490
 
                    AV_COPY32(h->mv_cache[m][scan8[0] - 1 + i*8], s->current_picture.f.motion_val[m][b_xy - 1 + i*h->b_stride]);
491
 
                }
 
510
            if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
 
511
                for (i = 0; i < 4; i++)
 
512
                    AV_COPY32(h->mv_cache[m][scan8[0] - 1 + i * 8],
 
513
                              s->current_picture.f.motion_val[m][b_xy - 1 + i * h->b_stride]);
492
514
            } else {
493
 
                for (i = 0; i < 4; i++) {
494
 
                    AV_ZERO32(h->mv_cache[m][scan8[0] - 1 + i*8]);
495
 
                }
 
515
                for (i = 0; i < 4; i++)
 
516
                    AV_ZERO32(h->mv_cache[m][scan8[0] - 1 + i * 8]);
496
517
            }
497
518
            if (s->mb_y > 0) {
498
 
                memcpy(h->mv_cache[m][scan8[0] - 1*8], s->current_picture.f.motion_val[m][b_xy - h->b_stride], 4*2*sizeof(int16_t));
499
 
                memset(&h->ref_cache[m][scan8[0] - 1*8], (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
 
519
                memcpy(h->mv_cache[m][scan8[0] - 1 * 8],
 
520
                       s->current_picture.f.motion_val[m][b_xy - h->b_stride],
 
521
                       4 * 2 * sizeof(int16_t));
 
522
                memset(&h->ref_cache[m][scan8[0] - 1 * 8],
 
523
                       (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
500
524
 
501
 
                if (s->mb_x < (s->mb_width - 1)) {
502
 
                    AV_COPY32(h->mv_cache[m][scan8[0] + 4 - 1*8], s->current_picture.f.motion_val[m][b_xy - h->b_stride + 4]);
503
 
                    h->ref_cache[m][scan8[0] + 4 - 1*8] =
504
 
                        (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1]+6] == -1 ||
505
 
                         h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride    ]  ] == -1) ? PART_NOT_AVAILABLE : 1;
506
 
                }else
507
 
                    h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
 
525
                if (s->mb_x < s->mb_width - 1) {
 
526
                    AV_COPY32(h->mv_cache[m][scan8[0] + 4 - 1 * 8],
 
527
                              s->current_picture.f.motion_val[m][b_xy - h->b_stride + 4]);
 
528
                    h->ref_cache[m][scan8[0] + 4 - 1 * 8] =
 
529
                        (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
 
530
                         h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
 
531
                } else
 
532
                    h->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
508
533
                if (s->mb_x > 0) {
509
 
                    AV_COPY32(h->mv_cache[m][scan8[0] - 1 - 1*8], s->current_picture.f.motion_val[m][b_xy - h->b_stride - 1]);
510
 
                    h->ref_cache[m][scan8[0] - 1 - 1*8] = (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] == -1) ? PART_NOT_AVAILABLE : 1;
511
 
                }else
512
 
                    h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
513
 
            }else
514
 
                memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
 
534
                    AV_COPY32(h->mv_cache[m][scan8[0] - 1 - 1 * 8],
 
535
                              s->current_picture.f.motion_val[m][b_xy - h->b_stride - 1]);
 
536
                    h->ref_cache[m][scan8[0] - 1 - 1 * 8] =
 
537
                        (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
 
538
                } else
 
539
                    h->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
 
540
            } else
 
541
                memset(&h->ref_cache[m][scan8[0] - 1 * 8 - 1],
 
542
                       PART_NOT_AVAILABLE, 8);
515
543
 
516
544
            if (s->pict_type != AV_PICTURE_TYPE_B)
517
545
                break;
519
547
 
520
548
        /* decode motion vector(s) and form prediction(s) */
521
549
        if (s->pict_type == AV_PICTURE_TYPE_P) {
522
 
            if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
 
550
            if (svq3_mc_dir(h, mb_type - 1, mode, 0, 0) < 0)
523
551
                return -1;
524
552
        } else {        /* AV_PICTURE_TYPE_B */
525
553
            if (mb_type != 2) {
526
554
                if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
527
555
                    return -1;
528
556
            } else {
529
 
                for (i = 0; i < 4; i++) {
530
 
                    memset(s->current_picture.f.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
531
 
                }
 
557
                for (i = 0; i < 4; i++)
 
558
                    memset(s->current_picture.f.motion_val[0][b_xy + i * h->b_stride],
 
559
                           0, 4 * 2 * sizeof(int16_t));
532
560
            }
533
561
            if (mb_type != 1) {
534
 
                if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
 
562
                if (svq3_mc_dir(h, 0, mode, 1, mb_type == 3) < 0)
535
563
                    return -1;
536
564
            } else {
537
 
                for (i = 0; i < 4; i++) {
538
 
                    memset(s->current_picture.f.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
539
 
                }
 
565
                for (i = 0; i < 4; i++)
 
566
                    memset(s->current_picture.f.motion_val[1][b_xy + i * h->b_stride],
 
567
                           0, 4 * 2 * sizeof(int16_t));
540
568
            }
541
569
        }
542
570
 
543
571
        mb_type = MB_TYPE_16x16;
544
572
    } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
545
 
        memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
 
573
        memset(h->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
546
574
 
547
575
        if (mb_type == 8) {
548
576
            if (s->mb_x > 0) {
549
 
                for (i = 0; i < 4; i++) {
550
 
                    h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6-i];
551
 
                }
552
 
                if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
 
577
                for (i = 0; i < 4; i++)
 
578
                    h->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
 
579
                if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
553
580
                    h->left_samples_available = 0x5F5F;
554
 
                }
555
581
            }
556
582
            if (s->mb_y > 0) {
557
 
                h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+0];
558
 
                h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+1];
559
 
                h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+2];
560
 
                h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+3];
 
583
                h->intra4x4_pred_mode_cache[4 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 0];
 
584
                h->intra4x4_pred_mode_cache[5 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 1];
 
585
                h->intra4x4_pred_mode_cache[6 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 2];
 
586
                h->intra4x4_pred_mode_cache[7 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 3];
561
587
 
562
 
                if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
 
588
                if (h->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
563
589
                    h->top_samples_available = 0x33FF;
564
 
                }
565
590
            }
566
591
 
567
592
            /* decode prediction codes for luma blocks */
568
 
            for (i = 0; i < 16; i+=2) {
 
593
            for (i = 0; i < 16; i += 2) {
569
594
                vlc = svq3_get_ue_golomb(&s->gb);
570
595
 
571
 
                if (vlc >= 25){
 
596
                if (vlc >= 25) {
572
597
                    av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
573
598
                    return -1;
574
599
                }
575
600
 
576
 
                left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
577
 
                top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
 
601
                left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
 
602
                top  = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
578
603
 
579
604
                left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
580
605
                left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
581
606
 
582
 
                if (left[1] == -1 || left[2] == -1){
 
607
                if (left[1] == -1 || left[2] == -1) {
583
608
                    av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
584
609
                    return -1;
585
610
                }
586
611
            }
587
612
        } else {    /* mb_type == 33, DC_128_PRED block type */
588
 
            for (i = 0; i < 4; i++) {
589
 
                memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
590
 
            }
 
613
            for (i = 0; i < 4; i++)
 
614
                memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
591
615
        }
592
616
 
593
617
        write_back_intra_pred_mode(h);
598
622
            h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
599
623
            h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
600
624
        } else {
601
 
            for (i = 0; i < 4; i++) {
602
 
                memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
603
 
            }
 
625
            for (i = 0; i < 4; i++)
 
626
                memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
604
627
 
605
628
            h->top_samples_available  = 0x33FF;
606
629
            h->left_samples_available = 0x5F5F;
609
632
        mb_type = MB_TYPE_INTRA4x4;
610
633
    } else {                      /* INTRA16x16 */
611
634
        dir = i_mb_type_info[mb_type - 8].pred_mode;
612
 
        dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
 
635
        dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
613
636
 
614
 
        if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) == -1){
615
 
            av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
616
 
            return -1;
 
637
        if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) < 0) {
 
638
            av_log(h->s.avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
 
639
            return h->intra16x16_pred_mode;
617
640
        }
618
641
 
619
 
        cbp = i_mb_type_info[mb_type - 8].cbp;
 
642
        cbp     = i_mb_type_info[mb_type - 8].cbp;
620
643
        mb_type = MB_TYPE_INTRA16x16;
621
644
    }
622
645
 
623
646
    if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
624
 
        for (i = 0; i < 4; i++) {
625
 
            memset(s->current_picture.f.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
626
 
        }
 
647
        for (i = 0; i < 4; i++)
 
648
            memset(s->current_picture.f.motion_val[0][b_xy + i * h->b_stride],
 
649
                   0, 4 * 2 * sizeof(int16_t));
627
650
        if (s->pict_type == AV_PICTURE_TYPE_B) {
628
 
            for (i = 0; i < 4; i++) {
629
 
                memset(s->current_picture.f.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
630
 
            }
 
651
            for (i = 0; i < 4; i++)
 
652
                memset(s->current_picture.f.motion_val[1][b_xy + i * h->b_stride],
 
653
                       0, 4 * 2 * sizeof(int16_t));
631
654
        }
632
655
    }
633
656
    if (!IS_INTRA4x4(mb_type)) {
634
 
        memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy], DC_PRED, 8);
 
657
        memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
635
658
    }
636
659
    if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
637
 
        memset(h->non_zero_count_cache + 8, 0, 14*8*sizeof(uint8_t));
638
 
        s->dsp.clear_blocks(h->mb+  0);
639
 
        s->dsp.clear_blocks(h->mb+384);
 
660
        memset(h->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
 
661
        s->dsp.clear_blocks(h->mb +   0);
 
662
        s->dsp.clear_blocks(h->mb + 384);
640
663
    }
641
664
 
642
 
    if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
643
 
        if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
 
665
    if (!IS_INTRA16x16(mb_type) &&
 
666
        (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
 
667
        if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48) {
644
668
            av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
645
669
            return -1;
646
670
        }
647
671
 
648
 
        cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
 
672
        cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc]
 
673
                                : golomb_to_inter_cbp[vlc];
649
674
    }
650
 
    if (IS_INTRA16x16(mb_type) || (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
 
675
    if (IS_INTRA16x16(mb_type) ||
 
676
        (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
651
677
        s->qscale += svq3_get_se_golomb(&s->gb);
652
678
 
653
 
        if (s->qscale > 31u){
 
679
        if (s->qscale > 31u) {
654
680
            av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
655
681
            return -1;
656
682
        }
657
683
    }
658
684
    if (IS_INTRA16x16(mb_type)) {
659
 
        AV_ZERO128(h->mb_luma_dc[0]+0);
660
 
        AV_ZERO128(h->mb_luma_dc[0]+8);
661
 
        if (svq3_decode_block(&s->gb, h->mb_luma_dc, 0, 1)){
662
 
            av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
 
685
        AV_ZERO128(h->mb_luma_dc[0] + 0);
 
686
        AV_ZERO128(h->mb_luma_dc[0] + 8);
 
687
        if (svq3_decode_block(&s->gb, h->mb_luma_dc[0], 0, 1)) {
 
688
            av_log(h->s.avctx, AV_LOG_ERROR,
 
689
                   "error while decoding intra luma dc\n");
663
690
            return -1;
664
691
        }
665
692
    }
666
693
 
667
694
    if (cbp) {
668
695
        const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
669
 
        const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
 
696
        const int type  = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
670
697
 
671
 
        for (i = 0; i < 4; i++) {
 
698
        for (i = 0; i < 4; i++)
672
699
            if ((cbp & (1 << i))) {
673
700
                for (j = 0; j < 4; j++) {
674
 
                    k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
675
 
                    h->non_zero_count_cache[ scan8[k] ] = 1;
 
701
                    k = index ? (1 * (j & 1) + 2 * (i & 1) +
 
702
                                 2 * (j & 2) + 4 * (i & 2))
 
703
                              : (4 * i + j);
 
704
                    h->non_zero_count_cache[scan8[k]] = 1;
676
705
 
677
 
                    if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
678
 
                        av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
 
706
                    if (svq3_decode_block(&s->gb, &h->mb[16 * k], index, type)) {
 
707
                        av_log(h->s.avctx, AV_LOG_ERROR,
 
708
                               "error while decoding block\n");
679
709
                        return -1;
680
710
                    }
681
711
                }
682
712
            }
683
 
        }
684
713
 
685
714
        if ((cbp & 0x30)) {
686
 
            for (i = 1; i < 3; ++i) {
687
 
              if (svq3_decode_block(&s->gb, &h->mb[16*16*i], 0, 3)){
688
 
                av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
689
 
                return -1;
690
 
              }
691
 
            }
 
715
            for (i = 1; i < 3; ++i)
 
716
                if (svq3_decode_block(&s->gb, &h->mb[16 * 16 * i], 0, 3)) {
 
717
                    av_log(h->s.avctx, AV_LOG_ERROR,
 
718
                           "error while decoding chroma dc block\n");
 
719
                    return -1;
 
720
                }
692
721
 
693
722
            if ((cbp & 0x20)) {
694
723
                for (i = 1; i < 3; i++) {
695
724
                    for (j = 0; j < 4; j++) {
696
 
                        k = 16*i + j;
697
 
                        h->non_zero_count_cache[ scan8[k] ] = 1;
 
725
                        k                                 = 16 * i + j;
 
726
                        h->non_zero_count_cache[scan8[k]] = 1;
698
727
 
699
 
                        if (svq3_decode_block(&s->gb, &h->mb[16*k], 1, 1)){
700
 
                            av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
 
728
                        if (svq3_decode_block(&s->gb, &h->mb[16 * k], 1, 1)) {
 
729
                            av_log(h->s.avctx, AV_LOG_ERROR,
 
730
                                   "error while decoding chroma ac block\n");
701
731
                            return -1;
702
732
                        }
703
733
                    }
706
736
        }
707
737
    }
708
738
 
709
 
    h->cbp= cbp;
 
739
    h->cbp                              = cbp;
710
740
    s->current_picture.f.mb_type[mb_xy] = mb_type;
711
741
 
712
 
    if (IS_INTRA(mb_type)) {
 
742
    if (IS_INTRA(mb_type))
713
743
        h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8, 1);
714
 
    }
715
744
 
716
745
    return 0;
717
746
}
719
748
static int svq3_decode_slice_header(AVCodecContext *avctx)
720
749
{
721
750
    SVQ3Context *svq3 = avctx->priv_data;
722
 
    H264Context *h = &svq3->h;
 
751
    H264Context *h    = &svq3->h;
723
752
    MpegEncContext *s = &h->s;
724
 
    const int mb_xy = h->mb_xy;
 
753
    const int mb_xy   = h->mb_xy;
725
754
    int i, header;
 
755
    unsigned slice_id;
726
756
 
727
757
    header = get_bits(&s->gb, 8);
728
758
 
731
761
        av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
732
762
        return -1;
733
763
    } else {
734
 
        int length = (header >> 5) & 3;
 
764
        int length = header >> 5 & 3;
735
765
 
736
 
        svq3->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
 
766
        svq3->next_slice_index = get_bits_count(&s->gb) +
 
767
                                 8 * show_bits(&s->gb, 8 * length) +
 
768
                                 8 * length;
737
769
 
738
770
        if (svq3->next_slice_index > s->gb.size_in_bits) {
739
771
            av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
740
772
            return -1;
741
 
    }
 
773
        }
742
774
 
743
 
        s->gb.size_in_bits = svq3->next_slice_index - 8*(length - 1);
 
775
        s->gb.size_in_bits = svq3->next_slice_index - 8 * (length - 1);
744
776
        skip_bits(&s->gb, 8);
745
777
 
746
778
        if (svq3->watermark_key) {
747
 
            uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
748
 
            AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ svq3->watermark_key);
 
779
            uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb) >> 3) + 1]);
 
780
            AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb) >> 3) + 1],
 
781
                    header ^ svq3->watermark_key);
749
782
        }
750
783
        if (length > 0) {
751
784
            memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
752
 
                   &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
 
785
                   &s->gb.buffer[s->gb.size_in_bits >> 3], length - 1);
753
786
        }
754
787
        skip_bits_long(&s->gb, 0);
755
788
    }
756
789
 
757
 
    if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
758
 
        av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
 
790
    if ((slice_id = svq3_get_ue_golomb(&s->gb)) >= 3) {
 
791
        av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", slice_id);
759
792
        return -1;
760
793
    }
761
794
 
762
 
    h->slice_type = golomb_to_pict_type[i];
 
795
    h->slice_type = golomb_to_pict_type[slice_id];
763
796
 
764
797
    if ((header & 0x9F) == 2) {
765
 
        i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
766
 
        s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
 
798
        i              = (s->mb_num < 64) ? 6 : (1 + av_log2(s->mb_num - 1));
 
799
        s->mb_skip_run = get_bits(&s->gb, i) -
 
800
                         (s->mb_y * s->mb_width + s->mb_x);
767
801
    } else {
768
802
        skip_bits1(&s->gb);
769
803
        s->mb_skip_run = 0;
770
804
    }
771
805
 
772
 
    h->slice_num = get_bits(&s->gb, 8);
773
 
    s->qscale = get_bits(&s->gb, 5);
 
806
    h->slice_num      = get_bits(&s->gb, 8);
 
807
    s->qscale         = get_bits(&s->gb, 5);
774
808
    s->adaptive_quant = get_bits1(&s->gb);
775
809
 
776
810
    /* unknown fields */
777
811
    skip_bits1(&s->gb);
778
812
 
779
 
    if (svq3->unknown_flag) {
 
813
    if (svq3->unknown_flag)
780
814
        skip_bits1(&s->gb);
781
 
    }
782
815
 
783
816
    skip_bits1(&s->gb);
784
817
    skip_bits(&s->gb, 2);
785
818
 
786
 
    while (get_bits1(&s->gb)) {
 
819
    while (get_bits1(&s->gb))
787
820
        skip_bits(&s->gb, 8);
788
 
    }
789
821
 
790
822
    /* reset intra predictors and invalidate motion vector references */
791
823
    if (s->mb_x > 0) {
792
 
        memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - 1      ]+3, -1, 4*sizeof(int8_t));
793
 
        memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_x]  , -1, 8*sizeof(int8_t)*s->mb_x);
 
824
        memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
 
825
               -1, 4 * sizeof(int8_t));
 
826
        memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - s->mb_x],
 
827
               -1, 8 * sizeof(int8_t) * s->mb_x);
794
828
    }
795
829
    if (s->mb_y > 0) {
796
 
        memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
 
830
        memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - s->mb_stride],
 
831
               -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
797
832
 
798
 
        if (s->mb_x > 0) {
799
 
            h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] = -1;
800
 
        }
 
833
        if (s->mb_x > 0)
 
834
            h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
801
835
    }
802
836
 
803
837
    return 0;
806
840
static av_cold int svq3_decode_init(AVCodecContext *avctx)
807
841
{
808
842
    SVQ3Context *svq3 = avctx->priv_data;
809
 
    H264Context *h = &svq3->h;
 
843
    H264Context *h    = &svq3->h;
810
844
    MpegEncContext *s = &h->s;
811
845
    int m;
812
846
    unsigned char *extradata;
817
851
    if (ff_h264_decode_init(avctx) < 0)
818
852
        return -1;
819
853
 
820
 
    s->flags  = avctx->flags;
821
 
    s->flags2 = avctx->flags2;
 
854
    s->flags           = avctx->flags;
 
855
    s->flags2          = avctx->flags2;
822
856
    s->unrestricted_mv = 1;
823
 
    h->is_complex=1;
824
 
    avctx->pix_fmt = avctx->codec->pix_fmts[0];
 
857
    h->is_complex      = 1;
 
858
    avctx->pix_fmt     = avctx->codec->pix_fmts[0];
825
859
 
826
860
    if (!s->context_initialized) {
827
861
        h->chroma_qp[0] = h->chroma_qp[1] = 4;
831
865
        svq3->unknown_flag  = 0;
832
866
 
833
867
        /* prowl for the "SEQH" marker in the extradata */
834
 
        extradata = (unsigned char *)avctx->extradata;
 
868
        extradata     = (unsigned char *)avctx->extradata;
835
869
        extradata_end = avctx->extradata + avctx->extradata_size;
836
870
        if (extradata) {
837
871
            for (m = 0; m + 8 < avctx->extradata_size; m++) {
845
879
 
846
880
        /* if a match was found, parse the extra data */
847
881
        if (marker_found) {
848
 
 
849
882
            GetBitContext gb;
850
883
            int frame_size_code;
851
884
 
852
885
            size = AV_RB32(&extradata[4]);
853
886
            if (size > extradata_end - extradata - 8)
854
887
                return AVERROR_INVALIDDATA;
855
 
            init_get_bits(&gb, extradata + 8, size*8);
 
888
            init_get_bits(&gb, extradata + 8, size * 8);
856
889
 
857
890
            /* 'frame size code' and optional 'width, height' */
858
891
            frame_size_code = get_bits(&gb, 3);
859
892
            switch (frame_size_code) {
860
 
                case 0: avctx->width = 160; avctx->height = 120; break;
861
 
                case 1: avctx->width = 128; avctx->height =  96; break;
862
 
                case 2: avctx->width = 176; avctx->height = 144; break;
863
 
                case 3: avctx->width = 352; avctx->height = 288; break;
864
 
                case 4: avctx->width = 704; avctx->height = 576; break;
865
 
                case 5: avctx->width = 240; avctx->height = 180; break;
866
 
                case 6: avctx->width = 320; avctx->height = 240; break;
867
 
                case 7:
868
 
                    avctx->width  = get_bits(&gb, 12);
869
 
                    avctx->height = get_bits(&gb, 12);
870
 
                    break;
 
893
            case 0:
 
894
                avctx->width  = 160;
 
895
                avctx->height = 120;
 
896
                break;
 
897
            case 1:
 
898
                avctx->width  = 128;
 
899
                avctx->height =  96;
 
900
                break;
 
901
            case 2:
 
902
                avctx->width  = 176;
 
903
                avctx->height = 144;
 
904
                break;
 
905
            case 3:
 
906
                avctx->width  = 352;
 
907
                avctx->height = 288;
 
908
                break;
 
909
            case 4:
 
910
                avctx->width  = 704;
 
911
                avctx->height = 576;
 
912
                break;
 
913
            case 5:
 
914
                avctx->width  = 240;
 
915
                avctx->height = 180;
 
916
                break;
 
917
            case 6:
 
918
                avctx->width  = 320;
 
919
                avctx->height = 240;
 
920
                break;
 
921
            case 7:
 
922
                avctx->width  = get_bits(&gb, 12);
 
923
                avctx->height = get_bits(&gb, 12);
 
924
                break;
871
925
            }
872
926
 
873
927
            svq3->halfpel_flag  = get_bits1(&gb);
884
938
            /* unknown field */
885
939
            skip_bits1(&gb);
886
940
 
887
 
            while (get_bits1(&gb)) {
 
941
            while (get_bits1(&gb))
888
942
                skip_bits(&gb, 8);
889
 
            }
890
943
 
891
 
            svq3->unknown_flag = get_bits1(&gb);
 
944
            svq3->unknown_flag  = get_bits1(&gb);
892
945
            avctx->has_b_frames = !s->low_delay;
893
946
            if (svq3->unknown_flag) {
894
947
#if CONFIG_ZLIB
895
948
                unsigned watermark_width  = svq3_get_ue_golomb(&gb);
896
949
                unsigned watermark_height = svq3_get_ue_golomb(&gb);
897
 
                int u1 = svq3_get_ue_golomb(&gb);
898
 
                int u2 = get_bits(&gb, 8);
899
 
                int u3 = get_bits(&gb, 2);
900
 
                int u4 = svq3_get_ue_golomb(&gb);
901
 
                unsigned long buf_len = watermark_width*watermark_height*4;
902
 
                int offset = (get_bits_count(&gb)+7)>>3;
 
950
                int u1                    = svq3_get_ue_golomb(&gb);
 
951
                int u2                    = get_bits(&gb, 8);
 
952
                int u3                    = get_bits(&gb, 2);
 
953
                int u4                    = svq3_get_ue_golomb(&gb);
 
954
                unsigned long buf_len     = watermark_width *
 
955
                                            watermark_height * 4;
 
956
                int offset                = get_bits_count(&gb) + 7 >> 3;
903
957
                uint8_t *buf;
904
958
 
905
 
                if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
 
959
                if (watermark_height > 0 &&
 
960
                    (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
906
961
                    return -1;
907
962
 
908
963
                buf = av_malloc(buf_len);
909
 
                av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
910
 
                av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
911
 
                if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
912
 
                    av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
 
964
                av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n",
 
965
                       watermark_width, watermark_height);
 
966
                av_log(avctx, AV_LOG_DEBUG,
 
967
                       "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
 
968
                       u1, u2, u3, u4, offset);
 
969
                if (uncompress(buf, &buf_len, extradata + 8 + offset,
 
970
                               size - offset) != Z_OK) {
 
971
                    av_log(avctx, AV_LOG_ERROR,
 
972
                           "could not uncompress watermark logo\n");
913
973
                    av_free(buf);
914
974
                    return -1;
915
975
                }
916
976
                svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
917
 
                svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;
918
 
                av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", svq3->watermark_key);
 
977
                svq3->watermark_key = svq3->watermark_key << 16 |
 
978
                                      svq3->watermark_key;
 
979
                av_log(avctx, AV_LOG_DEBUG,
 
980
                       "watermark key %#x\n", svq3->watermark_key);
919
981
                av_free(buf);
920
982
#else
921
 
                av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
 
983
                av_log(avctx, AV_LOG_ERROR,
 
984
                       "this svq3 file contains watermark which need zlib support compiled in\n");
922
985
                return -1;
923
986
#endif
924
987
            }
927
990
        s->width  = avctx->width;
928
991
        s->height = avctx->height;
929
992
 
930
 
        if (MPV_common_init(s) < 0)
 
993
        if (ff_MPV_common_init(s) < 0)
931
994
            return -1;
932
995
 
933
 
        h->b_stride = 4*s->mb_width;
 
996
        h->b_stride = 4 * s->mb_width;
934
997
 
935
998
        if (ff_h264_alloc_tables(h) < 0) {
936
999
            av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
941
1004
    return 0;
942
1005
}
943
1006
 
944
 
static int svq3_decode_frame(AVCodecContext *avctx,
945
 
                             void *data, int *data_size,
946
 
                             AVPacket *avpkt)
 
1007
static int svq3_decode_frame(AVCodecContext *avctx, void *data,
 
1008
                             int *got_frame, AVPacket *avpkt)
947
1009
{
948
1010
    const uint8_t *buf = avpkt->data;
949
 
    SVQ3Context *svq3 = avctx->priv_data;
950
 
    H264Context *h = &svq3->h;
951
 
    MpegEncContext *s = &h->s;
952
 
    int buf_size = avpkt->size;
953
 
    int m, mb_type;
 
1011
    SVQ3Context *svq3  = avctx->priv_data;
 
1012
    H264Context *h     = &svq3->h;
 
1013
    MpegEncContext *s  = &h->s;
 
1014
    int buf_size       = avpkt->size;
 
1015
    int m;
954
1016
 
955
1017
    /* special case for last picture */
956
1018
    if (buf_size == 0) {
957
1019
        if (s->next_picture_ptr && !s->low_delay) {
958
 
            *(AVFrame *) data = *(AVFrame *) &s->next_picture;
 
1020
            *(AVFrame *) data   = s->next_picture.f;
959
1021
            s->next_picture_ptr = NULL;
960
 
            *data_size = sizeof(AVFrame);
 
1022
            *got_frame          = 1;
961
1023
        }
962
1024
        return 0;
963
1025
    }
964
1026
 
965
 
    init_get_bits (&s->gb, buf, 8*buf_size);
 
1027
    init_get_bits(&s->gb, buf, 8 * buf_size);
966
1028
 
967
1029
    s->mb_x = s->mb_y = h->mb_xy = 0;
968
1030
 
969
1031
    if (svq3_decode_slice_header(avctx))
970
1032
        return -1;
971
1033
 
972
 
    s->pict_type = h->slice_type;
 
1034
    s->pict_type      = h->slice_type;
973
1035
    s->picture_number = h->slice_num;
974
1036
 
975
 
    if (avctx->debug&FF_DEBUG_PICT_INFO){
976
 
        av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
977
 
               av_get_picture_type_char(s->pict_type), svq3->halfpel_flag, svq3->thirdpel_flag,
 
1037
    if (avctx->debug & FF_DEBUG_PICT_INFO)
 
1038
        av_log(h->s.avctx, AV_LOG_DEBUG,
 
1039
               "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
 
1040
               av_get_picture_type_char(s->pict_type),
 
1041
               svq3->halfpel_flag, svq3->thirdpel_flag,
978
1042
               s->adaptive_quant, s->qscale, h->slice_num);
979
 
    }
980
1043
 
981
1044
    /* for skipping the frame */
982
1045
    s->current_picture.f.pict_type = s->pict_type;
985
1048
    /* Skip B-frames if we do not have reference frames. */
986
1049
    if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
987
1050
        return 0;
988
 
    if (  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
989
 
        ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
990
 
        || avctx->skip_frame >= AVDISCARD_ALL)
 
1051
    if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
 
1052
        avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I ||
 
1053
        avctx->skip_frame >= AVDISCARD_ALL)
991
1054
        return 0;
992
1055
 
993
1056
    if (s->next_p_frame_damaged) {
1001
1064
        return -1;
1002
1065
 
1003
1066
    if (s->pict_type == AV_PICTURE_TYPE_B) {
1004
 
        h->frame_num_offset = (h->slice_num - h->prev_frame_num);
 
1067
        h->frame_num_offset = h->slice_num - h->prev_frame_num;
1005
1068
 
1006
 
        if (h->frame_num_offset < 0) {
 
1069
        if (h->frame_num_offset < 0)
1007
1070
            h->frame_num_offset += 256;
1008
 
        }
1009
 
        if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
 
1071
        if (h->frame_num_offset == 0 ||
 
1072
            h->frame_num_offset >= h->prev_frame_num_offset) {
1010
1073
            av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1011
1074
            return -1;
1012
1075
        }
1013
1076
    } else {
1014
 
        h->prev_frame_num = h->frame_num;
1015
 
        h->frame_num = h->slice_num;
1016
 
        h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
 
1077
        h->prev_frame_num        = h->frame_num;
 
1078
        h->frame_num             = h->slice_num;
 
1079
        h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1017
1080
 
1018
 
        if (h->prev_frame_num_offset < 0) {
 
1081
        if (h->prev_frame_num_offset < 0)
1019
1082
            h->prev_frame_num_offset += 256;
1020
 
        }
1021
1083
    }
1022
1084
 
1023
 
    for (m = 0; m < 2; m++){
 
1085
    for (m = 0; m < 2; m++) {
1024
1086
        int i;
1025
 
        for (i = 0; i < 4; i++){
 
1087
        for (i = 0; i < 4; i++) {
1026
1088
            int j;
1027
1089
            for (j = -1; j < 4; j++)
1028
 
                h->ref_cache[m][scan8[0] + 8*i + j]= 1;
 
1090
                h->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1029
1091
            if (i < 3)
1030
 
                h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
 
1092
                h->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1031
1093
        }
1032
1094
    }
1033
1095
 
1034
1096
    for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1035
1097
        for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1036
 
            h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1037
 
 
1038
 
            if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1039
 
                ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1040
 
 
 
1098
            unsigned mb_type;
 
1099
            h->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
 
1100
 
 
1101
            if ((get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
 
1102
                ((get_bits_count(&s->gb) & 7) == 0 ||
 
1103
                 show_bits(&s->gb, -get_bits_count(&s->gb) & 7) == 0)) {
1041
1104
                skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
1042
 
                s->gb.size_in_bits = 8*buf_size;
 
1105
                s->gb.size_in_bits = 8 * buf_size;
1043
1106
 
1044
1107
                if (svq3_decode_slice_header(avctx))
1045
1108
                    return -1;
1049
1112
 
1050
1113
            mb_type = svq3_get_ue_golomb(&s->gb);
1051
1114
 
1052
 
            if (s->pict_type == AV_PICTURE_TYPE_I) {
 
1115
            if (s->pict_type == AV_PICTURE_TYPE_I)
1053
1116
                mb_type += 8;
1054
 
            } else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4) {
 
1117
            else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1055
1118
                mb_type += 4;
1056
 
            }
1057
 
            if ((unsigned)mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
1058
 
                av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
 
1119
            if (mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
 
1120
                av_log(h->s.avctx, AV_LOG_ERROR,
 
1121
                       "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1059
1122
                return -1;
1060
1123
            }
1061
1124
 
1062
 
            if (mb_type != 0) {
1063
 
                ff_h264_hl_decode_mb (h);
1064
 
            }
 
1125
            if (mb_type != 0)
 
1126
                ff_h264_hl_decode_mb(h);
1065
1127
 
1066
 
            if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay) {
 
1128
            if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1067
1129
                s->current_picture.f.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1068
1130
                    (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1069
 
            }
1070
1131
        }
1071
1132
 
1072
 
        ff_draw_horiz_band(s, 16*s->mb_y, 16);
1073
 
    }
1074
 
 
1075
 
    MPV_frame_end(s);
1076
 
 
1077
 
    if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1078
 
        *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1079
 
    } else {
1080
 
        *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1081
 
    }
 
1133
        ff_draw_horiz_band(s, 16 * s->mb_y, 16);
 
1134
    }
 
1135
 
 
1136
    ff_MPV_frame_end(s);
 
1137
 
 
1138
    if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
 
1139
        *(AVFrame *)data = s->current_picture.f;
 
1140
    else
 
1141
        *(AVFrame *)data = s->last_picture.f;
1082
1142
 
1083
1143
    /* Do not output the last pic after seeking. */
1084
 
    if (s->last_picture_ptr || s->low_delay) {
1085
 
        *data_size = sizeof(AVFrame);
1086
 
    }
 
1144
    if (s->last_picture_ptr || s->low_delay)
 
1145
        *got_frame = 1;
1087
1146
 
1088
1147
    return buf_size;
1089
1148
}
1091
1150
static int svq3_decode_end(AVCodecContext *avctx)
1092
1151
{
1093
1152
    SVQ3Context *svq3 = avctx->priv_data;
1094
 
    H264Context *h = &svq3->h;
 
1153
    H264Context *h    = &svq3->h;
1095
1154
    MpegEncContext *s = &h->s;
1096
1155
 
1097
1156
    ff_h264_free_context(h);
1098
1157
 
1099
 
    MPV_common_end(s);
 
1158
    ff_MPV_common_end(s);
1100
1159
 
1101
1160
    return 0;
1102
1161
}
1104
1163
AVCodec ff_svq3_decoder = {
1105
1164
    .name           = "svq3",
1106
1165
    .type           = AVMEDIA_TYPE_VIDEO,
1107
 
    .id             = CODEC_ID_SVQ3,
 
1166
    .id             = AV_CODEC_ID_SVQ3,
1108
1167
    .priv_data_size = sizeof(SVQ3Context),
1109
1168
    .init           = svq3_decode_init,
1110
1169
    .close          = svq3_decode_end,
1111
1170
    .decode         = svq3_decode_frame,
1112
 
    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1113
 
    .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1114
 
    .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
 
1171
    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND |
 
1172
                      CODEC_CAP_DR1             |
 
1173
                      CODEC_CAP_DELAY,
 
1174
    .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
 
1175
    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
 
1176
                                                     AV_PIX_FMT_NONE},
1115
1177
};