← Back to branch summary

~ppsspp/ppsspp/ffmpeg

« back to all changes in this revision

Viewing changes to libavcodec/mpegvideo_motion.c

  • Committer: Henrik Rydgård
  • Date: 2014-01-03 10:44:32 UTC
  • Revision ID: git-v1:87c6c126784b1718bfa448ecf2e6a9fef781eb4e
Update our ffmpeg snapshot to a clone of the official repository.

This is because Maxim's at3plus support has been officially merged!

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/mpegvideo_motion.c
38
38
                        uint8_t **ref_picture)
39
39
{
40
40
    uint8_t *ptr;
41
 
    int src_x, src_y;
 
41
    int src_x, src_y, motion_x, motion_y;
42
42
    ptrdiff_t offset, linesize, uvlinesize;
43
 
    int motion_x, motion_y;
44
 
    int emu=0;
 
43
    int emu = 0;
45
44
 
46
 
    motion_x= s->sprite_offset[0][0];
47
 
    motion_y= s->sprite_offset[0][1];
48
 
    src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
49
 
    src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
50
 
    motion_x<<=(3-s->sprite_warping_accuracy);
51
 
    motion_y<<=(3-s->sprite_warping_accuracy);
52
 
    src_x = av_clip(src_x, -16, s->width);
 
45
    motion_x   = s->sprite_offset[0][0];
 
46
    motion_y   = s->sprite_offset[0][1];
 
47
    src_x      = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy + 1));
 
48
    src_y      = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy + 1));
 
49
    motion_x <<= (3 - s->sprite_warping_accuracy);
 
50
    motion_y <<= (3 - s->sprite_warping_accuracy);
 
51
    src_x      = av_clip(src_x, -16, s->width);
53
52
    if (src_x == s->width)
54
 
        motion_x =0;
 
53
        motion_x = 0;
55
54
    src_y = av_clip(src_y, -16, s->height);
56
55
    if (src_y == s->height)
57
 
        motion_y =0;
 
56
        motion_y = 0;
58
57
 
59
 
    linesize = s->linesize;
 
58
    linesize   = s->linesize;
60
59
    uvlinesize = s->uvlinesize;
61
60
 
62
 
    ptr = ref_picture[0] + (src_y * linesize) + src_x;
 
61
    ptr = ref_picture[0] + src_y * linesize + src_x;
63
62
 
64
 
        if(   (unsigned)src_x >= FFMAX(s->h_edge_pos - 17, 0)
65
 
           || (unsigned)src_y >= FFMAX(s->v_edge_pos - 17, 0)){
66
 
            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, linesize,
67
 
                                     ptr, linesize, 17, 17, src_x, src_y,
 
63
        if ((unsigned)src_x >= FFMAX(s->h_edge_pos - 17, 0) ||
 
64
            (unsigned)src_y >= FFMAX(s->v_edge_pos - 17, 0)) {
 
65
            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
 
66
                                     linesize, linesize,
 
67
                                     17, 17,
 
68
                                     src_x, src_y,
68
69
                                     s->h_edge_pos, s->v_edge_pos);
69
 
            ptr= s->edge_emu_buffer;
 
70
            ptr = s->edge_emu_buffer;
70
71
        }
71
72
 
72
 
    if((motion_x|motion_y)&7){
73
 
        s->dsp.gmc1(dest_y  , ptr  , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
74
 
        s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
75
 
    }else{
 
73
    if ((motion_x | motion_y) & 7) {
 
74
        s->dsp.gmc1(dest_y, ptr, linesize, 16,
 
75
                    motion_x & 15, motion_y & 15, 128 - s->no_rounding);
 
76
        s->dsp.gmc1(dest_y + 8, ptr + 8, linesize, 16,
 
77
                    motion_x & 15, motion_y & 15, 128 - s->no_rounding);
 
78
    } else {
76
79
        int dxy;
77
80
 
78
 
        dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
79
 
        if (s->no_rounding){
 
81
        dxy = ((motion_x >> 3) & 1) | ((motion_y >> 2) & 2);
 
82
        if (s->no_rounding) {
80
83
            s->hdsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
81
 
        }else{
82
 
            s->hdsp.put_pixels_tab       [0][dxy](dest_y, ptr, linesize, 16);
 
84
        } else {
 
85
            s->hdsp.put_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
83
86
        }
84
87
    }
85
88
 
86
 
    if(CONFIG_GRAY && s->flags&CODEC_FLAG_GRAY) return;
 
89
    if (CONFIG_GRAY && s->flags & CODEC_FLAG_GRAY)
 
90
        return;
87
91
 
88
 
    motion_x= s->sprite_offset[1][0];
89
 
    motion_y= s->sprite_offset[1][1];
90
 
    src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
91
 
    src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
92
 
    motion_x<<=(3-s->sprite_warping_accuracy);
93
 
    motion_y<<=(3-s->sprite_warping_accuracy);
94
 
    src_x = av_clip(src_x, -8, s->width>>1);
95
 
    if (src_x == s->width>>1)
96
 
        motion_x =0;
97
 
    src_y = av_clip(src_y, -8, s->height>>1);
98
 
    if (src_y == s->height>>1)
99
 
        motion_y =0;
 
92
    motion_x   = s->sprite_offset[1][0];
 
93
    motion_y   = s->sprite_offset[1][1];
 
94
    src_x      = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy + 1));
 
95
    src_y      = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy + 1));
 
96
    motion_x <<= (3 - s->sprite_warping_accuracy);
 
97
    motion_y <<= (3 - s->sprite_warping_accuracy);
 
98
    src_x      = av_clip(src_x, -8, s->width >> 1);
 
99
    if (src_x == s->width >> 1)
 
100
        motion_x = 0;
 
101
    src_y = av_clip(src_y, -8, s->height >> 1);
 
102
    if (src_y == s->height >> 1)
 
103
        motion_y = 0;
100
104
 
101
105
    offset = (src_y * uvlinesize) + src_x;
102
 
    ptr = ref_picture[1] + offset;
103
 
        if(   (unsigned)src_x >= FFMAX((s->h_edge_pos>>1) - 9, 0)
104
 
           || (unsigned)src_y >= FFMAX((s->v_edge_pos>>1) - 9, 0)){
105
 
            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, uvlinesize,
106
 
                                     ptr, uvlinesize, 9, 9, src_x, src_y,
107
 
                                     s->h_edge_pos>>1, s->v_edge_pos>>1);
108
 
            ptr= s->edge_emu_buffer;
109
 
            emu=1;
 
106
    ptr    = ref_picture[1] + offset;
 
107
        if ((unsigned)src_x >= FFMAX((s->h_edge_pos >> 1) - 9, 0) ||
 
108
            (unsigned)src_y >= FFMAX((s->v_edge_pos >> 1) - 9, 0)) {
 
109
            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
 
110
                                     uvlinesize, uvlinesize,
 
111
                                     9, 9,
 
112
                                     src_x, src_y,
 
113
                                     s->h_edge_pos >> 1, s->v_edge_pos >> 1);
 
114
            ptr = s->edge_emu_buffer;
 
115
            emu = 1;
110
116
        }
111
 
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
 
117
    s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8,
 
118
                motion_x & 15, motion_y & 15, 128 - s->no_rounding);
112
119
 
113
120
    ptr = ref_picture[2] + offset;
114
 
    if(emu){
115
 
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, uvlinesize,
116
 
                                 ptr, uvlinesize, 9, 9, src_x, src_y,
117
 
                                 s->h_edge_pos>>1, s->v_edge_pos>>1);
118
 
        ptr= s->edge_emu_buffer;
 
121
    if (emu) {
 
122
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
 
123
                                 uvlinesize, uvlinesize,
 
124
                                 9, 9,
 
125
                                 src_x, src_y,
 
126
                                 s->h_edge_pos >> 1, s->v_edge_pos >> 1);
 
127
        ptr = s->edge_emu_buffer;
119
128
    }
120
 
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
121
 
 
122
 
    return;
 
129
    s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8,
 
130
                motion_x & 15, motion_y & 15, 128 - s->no_rounding);
123
131
}
124
132
 
125
133
static void gmc_motion(MpegEncContext *s,
128
136
{
129
137
    uint8_t *ptr;
130
138
    int linesize, uvlinesize;
131
 
    const int a= s->sprite_warping_accuracy;
 
139
    const int a = s->sprite_warping_accuracy;
132
140
    int ox, oy;
133
141
 
134
 
    linesize = s->linesize;
 
142
    linesize   = s->linesize;
135
143
    uvlinesize = s->uvlinesize;
136
144
 
137
145
    ptr = ref_picture[0];
138
146
 
139
 
    ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
140
 
    oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
 
147
    ox = s->sprite_offset[0][0] + s->sprite_delta[0][0] * s->mb_x * 16 +
 
148
         s->sprite_delta[0][1] * s->mb_y * 16;
 
149
    oy = s->sprite_offset[0][1] + s->sprite_delta[1][0] * s->mb_x * 16 +
 
150
         s->sprite_delta[1][1] * s->mb_y * 16;
141
151
 
142
152
    s->dsp.gmc(dest_y, ptr, linesize, 16,
143
 
           ox,
144
 
           oy,
145
 
           s->sprite_delta[0][0], s->sprite_delta[0][1],
146
 
           s->sprite_delta[1][0], s->sprite_delta[1][1],
147
 
           a+1, (1<<(2*a+1)) - s->no_rounding,
148
 
           s->h_edge_pos, s->v_edge_pos);
149
 
    s->dsp.gmc(dest_y+8, ptr, linesize, 16,
150
 
           ox + s->sprite_delta[0][0]*8,
151
 
           oy + s->sprite_delta[1][0]*8,
152
 
           s->sprite_delta[0][0], s->sprite_delta[0][1],
153
 
           s->sprite_delta[1][0], s->sprite_delta[1][1],
154
 
           a+1, (1<<(2*a+1)) - s->no_rounding,
155
 
           s->h_edge_pos, s->v_edge_pos);
156
 
 
157
 
    if(CONFIG_GRAY && s->flags&CODEC_FLAG_GRAY) return;
158
 
 
159
 
    ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
160
 
    oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
 
153
               ox, oy,
 
154
               s->sprite_delta[0][0], s->sprite_delta[0][1],
 
155
               s->sprite_delta[1][0], s->sprite_delta[1][1],
 
156
               a + 1, (1 << (2 * a + 1)) - s->no_rounding,
 
157
               s->h_edge_pos, s->v_edge_pos);
 
158
    s->dsp.gmc(dest_y + 8, ptr, linesize, 16,
 
159
               ox + s->sprite_delta[0][0] * 8,
 
160
               oy + s->sprite_delta[1][0] * 8,
 
161
               s->sprite_delta[0][0], s->sprite_delta[0][1],
 
162
               s->sprite_delta[1][0], s->sprite_delta[1][1],
 
163
               a + 1, (1 << (2 * a + 1)) - s->no_rounding,
 
164
               s->h_edge_pos, s->v_edge_pos);
 
165
 
 
166
    if (CONFIG_GRAY && s->flags & CODEC_FLAG_GRAY)
 
167
        return;
 
168
 
 
169
    ox = s->sprite_offset[1][0] + s->sprite_delta[0][0] * s->mb_x * 8 +
 
170
         s->sprite_delta[0][1] * s->mb_y * 8;
 
171
    oy = s->sprite_offset[1][1] + s->sprite_delta[1][0] * s->mb_x * 8 +
 
172
         s->sprite_delta[1][1] * s->mb_y * 8;
161
173
 
162
174
    ptr = ref_picture[1];
163
175
    s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
164
 
           ox,
165
 
           oy,
166
 
           s->sprite_delta[0][0], s->sprite_delta[0][1],
167
 
           s->sprite_delta[1][0], s->sprite_delta[1][1],
168
 
           a+1, (1<<(2*a+1)) - s->no_rounding,
169
 
           s->h_edge_pos>>1, s->v_edge_pos>>1);
 
176
               ox, oy,
 
177
               s->sprite_delta[0][0], s->sprite_delta[0][1],
 
178
               s->sprite_delta[1][0], s->sprite_delta[1][1],
 
179
               a + 1, (1 << (2 * a + 1)) - s->no_rounding,
 
180
               s->h_edge_pos >> 1, s->v_edge_pos >> 1);
170
181
 
171
182
    ptr = ref_picture[2];
172
183
    s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
173
 
           ox,
174
 
           oy,
175
 
           s->sprite_delta[0][0], s->sprite_delta[0][1],
176
 
           s->sprite_delta[1][0], s->sprite_delta[1][1],
177
 
           a+1, (1<<(2*a+1)) - s->no_rounding,
178
 
           s->h_edge_pos>>1, s->v_edge_pos>>1);
 
184
               ox, oy,
 
185
               s->sprite_delta[0][0], s->sprite_delta[0][1],
 
186
               s->sprite_delta[1][0], s->sprite_delta[1][1],
 
187
               a + 1, (1 << (2 * a + 1)) - s->no_rounding,
 
188
               s->h_edge_pos >> 1, s->v_edge_pos >> 1);
179
189
}
180
190
 
181
191
static inline int hpel_motion(MpegEncContext *s,
182
 
                                  uint8_t *dest, uint8_t *src,
183
 
                                  int src_x, int src_y,
184
 
                                  op_pixels_func *pix_op,
185
 
                                  int motion_x, int motion_y)
 
192
                              uint8_t *dest, uint8_t *src,
 
193
                              int src_x, int src_y,
 
194
                              op_pixels_func *pix_op,
 
195
                              int motion_x, int motion_y)
186
196
{
187
197
    int dxy = 0;
188
 
    int emu=0;
 
198
    int emu = 0;
189
199
 
190
200
    src_x += motion_x >> 1;
191
201
    src_y += motion_y >> 1;
192
202
 
193
203
    /* WARNING: do no forget half pels */
194
 
    src_x = av_clip(src_x, -16, s->width); //FIXME unneeded for emu?
 
204
    src_x = av_clip(src_x, -16, s->width); // FIXME unneeded for emu?
195
205
    if (src_x != s->width)
196
206
        dxy |= motion_x & 1;
197
207
    src_y = av_clip(src_y, -16, s->height);
199
209
        dxy |= (motion_y & 1) << 1;
200
210
    src += src_y * s->linesize + src_x;
201
211
 
202
 
    if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
203
 
        if(   (unsigned)src_x > FFMAX(s->h_edge_pos - (motion_x&1) - 8, 0)
204
 
           || (unsigned)src_y > FFMAX(s->v_edge_pos - (motion_y&1) - 8, 0)){
205
 
            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize,
206
 
                                     src, s->linesize, 9, 9,
207
 
                                     src_x, src_y, s->h_edge_pos, s->v_edge_pos);
208
 
            src= s->edge_emu_buffer;
209
 
            emu=1;
 
212
    if (s->flags & CODEC_FLAG_EMU_EDGE) {
 
213
        if ((unsigned)src_x > FFMAX(s->h_edge_pos - (motion_x & 1) - 8, 0) ||
 
214
            (unsigned)src_y > FFMAX(s->v_edge_pos - (motion_y & 1) - 8, 0)) {
 
215
            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
 
216
                                     s->linesize, s->linesize,
 
217
                                     9, 9,
 
218
                                     src_x, src_y,
 
219
                                     s->h_edge_pos, s->v_edge_pos);
 
220
            src = s->edge_emu_buffer;
 
221
            emu = 1;
210
222
        }
211
223
    }
212
224
    pix_op[dxy](dest, src, s->linesize, 8);
215
227
 
216
228
static av_always_inline
217
229
void mpeg_motion_internal(MpegEncContext *s,
218
 
                 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
219
 
                 int field_based, int bottom_field, int field_select,
220
 
                 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
221
 
                 int motion_x, int motion_y, int h, int is_mpeg12, int mb_y)
 
230
                          uint8_t *dest_y,
 
231
                          uint8_t *dest_cb,
 
232
                          uint8_t *dest_cr,
 
233
                          int field_based,
 
234
                          int bottom_field,
 
235
                          int field_select,
 
236
                          uint8_t **ref_picture,
 
237
                          op_pixels_func (*pix_op)[4],
 
238
                          int motion_x,
 
239
                          int motion_y,
 
240
                          int h,
 
241
                          int is_mpeg12,
 
242
                          int mb_y)
222
243
{
223
244
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
224
245
    int dxy, uvdxy, mx, my, src_x, src_y,
226
247
    ptrdiff_t uvlinesize, linesize;
227
248
 
228
249
#if 0
229
 
if(s->quarter_sample)
230
 
{
231
 
    motion_x>>=1;
232
 
    motion_y>>=1;
233
 
}
 
250
    if (s->quarter_sample) {
 
251
        motion_x >>= 1;
 
252
        motion_y >>= 1;
 
253
    }
234
254
#endif
235
255
 
236
256
    v_edge_pos = s->v_edge_pos >> field_based;
237
257
    linesize   = s->current_picture.f.linesize[0] << field_based;
238
258
    uvlinesize = s->current_picture.f.linesize[1] << field_based;
239
259
 
240
 
    dxy = ((motion_y & 1) << 1) | (motion_x & 1);
241
 
    src_x = s->mb_x* 16               + (motion_x >> 1);
242
 
    src_y =(   mb_y<<(4-field_based)) + (motion_y >> 1);
 
260
    dxy   = ((motion_y & 1) << 1) | (motion_x & 1);
 
261
    src_x = s->mb_x * 16 + (motion_x >> 1);
 
262
    src_y = (mb_y << (4 - field_based)) + (motion_y >> 1);
243
263
 
244
264
    if (!is_mpeg12 && s->out_format == FMT_H263) {
245
 
        if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
246
 
            mx = (motion_x>>1)|(motion_x&1);
247
 
            my = motion_y >>1;
248
 
            uvdxy = ((my & 1) << 1) | (mx & 1);
249
 
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
250
 
            uvsrc_y =(   mb_y<<(3-field_based))+ (my >> 1);
251
 
        }else{
252
 
            uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
253
 
            uvsrc_x = src_x>>1;
254
 
            uvsrc_y = src_y>>1;
 
265
        if ((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based) {
 
266
            mx      = (motion_x >> 1) | (motion_x & 1);
 
267
            my      = motion_y >> 1;
 
268
            uvdxy   = ((my & 1) << 1) | (mx & 1);
 
269
            uvsrc_x = s->mb_x * 8 + (mx >> 1);
 
270
            uvsrc_y = (mb_y << (3 - field_based)) + (my >> 1);
 
271
        } else {
 
272
            uvdxy   = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
 
273
            uvsrc_x = src_x >> 1;
 
274
            uvsrc_y = src_y >> 1;
255
275
        }
256
 
    }else if(!is_mpeg12 && s->out_format == FMT_H261){//even chroma mv's are full pel in H261
257
 
        mx = motion_x / 4;
258
 
        my = motion_y / 4;
259
 
        uvdxy = 0;
260
 
        uvsrc_x = s->mb_x*8 + mx;
261
 
        uvsrc_y =    mb_y*8 + my;
 
276
    // Even chroma mv's are full pel in H261
 
277
    } else if (!is_mpeg12 && s->out_format == FMT_H261) {
 
278
        mx      = motion_x / 4;
 
279
        my      = motion_y / 4;
 
280
        uvdxy   = 0;
 
281
        uvsrc_x = s->mb_x * 8 + mx;
 
282
        uvsrc_y = mb_y * 8 + my;
262
283
    } else {
263
 
        if(s->chroma_y_shift){
264
 
            mx = motion_x / 2;
265
 
            my = motion_y / 2;
266
 
            uvdxy = ((my & 1) << 1) | (mx & 1);
267
 
            uvsrc_x = s->mb_x* 8               + (mx >> 1);
268
 
            uvsrc_y =(   mb_y<<(3-field_based))+ (my >> 1);
 
284
        if (s->chroma_y_shift) {
 
285
            mx      = motion_x / 2;
 
286
            my      = motion_y / 2;
 
287
            uvdxy   = ((my & 1) << 1) | (mx & 1);
 
288
            uvsrc_x = s->mb_x * 8 + (mx >> 1);
 
289
            uvsrc_y = (mb_y << (3 - field_based)) + (my >> 1);
269
290
        } else {
270
 
            if(s->chroma_x_shift){
271
 
            //Chroma422
272
 
                mx = motion_x / 2;
273
 
                uvdxy = ((motion_y & 1) << 1) | (mx & 1);
274
 
                uvsrc_x = s->mb_x* 8           + (mx >> 1);
 
291
            if (s->chroma_x_shift) {
 
292
                // Chroma422
 
293
                mx      = motion_x / 2;
 
294
                uvdxy   = ((motion_y & 1) << 1) | (mx & 1);
 
295
                uvsrc_x = s->mb_x * 8 + (mx >> 1);
275
296
                uvsrc_y = src_y;
276
297
            } else {
277
 
            //Chroma444
278
 
                uvdxy = dxy;
 
298
                // Chroma444
 
299
                uvdxy   = dxy;
279
300
                uvsrc_x = src_x;
280
301
                uvsrc_y = src_y;
281
302
            }
286
307
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
287
308
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
288
309
 
289
 
    if(   (unsigned)src_x > FFMAX(s->h_edge_pos - (motion_x&1) - 16, 0)
290
 
       || (unsigned)src_y > FFMAX(   v_edge_pos - (motion_y&1) - h , 0)){
291
 
            if(is_mpeg12 || s->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
292
 
               s->codec_id == AV_CODEC_ID_MPEG1VIDEO){
293
 
                av_log(s->avctx,AV_LOG_DEBUG,
294
 
                        "MPEG motion vector out of boundary (%d %d)\n", src_x, src_y);
295
 
                return;
296
 
            }
297
 
            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize,
298
 
                                     ptr_y, s->linesize, 17, 17+field_based,
299
 
                                     src_x, src_y<<field_based,
300
 
                                     s->h_edge_pos, s->v_edge_pos);
301
 
            ptr_y = s->edge_emu_buffer;
302
 
            if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
303
 
                uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
304
 
                s->vdsp.emulated_edge_mc(uvbuf, s->uvlinesize,
305
 
                                    ptr_cb, s->uvlinesize,
306
 
                                    9, 9+field_based,
307
 
                                    uvsrc_x, uvsrc_y<<field_based,
308
 
                                    s->h_edge_pos>>1, s->v_edge_pos>>1);
309
 
                s->vdsp.emulated_edge_mc(uvbuf+16, s->uvlinesize,
310
 
                                    ptr_cr, s->uvlinesize,
311
 
                                    9, 9+field_based,
312
 
                                    uvsrc_x, uvsrc_y<<field_based,
313
 
                                    s->h_edge_pos>>1, s->v_edge_pos>>1);
314
 
                ptr_cb= uvbuf;
315
 
                ptr_cr= uvbuf+16;
316
 
            }
317
 
    }
318
 
 
319
 
    if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
320
 
        dest_y += s->linesize;
321
 
        dest_cb+= s->uvlinesize;
322
 
        dest_cr+= s->uvlinesize;
323
 
    }
324
 
 
325
 
    if(field_select){
326
 
        ptr_y += s->linesize;
327
 
        ptr_cb+= s->uvlinesize;
328
 
        ptr_cr+= s->uvlinesize;
 
310
    if ((unsigned)src_x > FFMAX(s->h_edge_pos - (motion_x & 1) - 16, 0) ||
 
311
        (unsigned)src_y > FFMAX(   v_edge_pos - (motion_y & 1) - h , 0)) {
 
312
        if (is_mpeg12 ||
 
313
            s->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
 
314
            s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
 
315
            av_log(s->avctx, AV_LOG_DEBUG,
 
316
                   "MPEG motion vector out of boundary (%d %d)\n", src_x,
 
317
                   src_y);
 
318
            return;
 
319
        }
 
320
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
 
321
                                 s->linesize, s->linesize,
 
322
                                 17, 17 + field_based,
 
323
                                 src_x, src_y << field_based,
 
324
                                 s->h_edge_pos, s->v_edge_pos);
 
325
        ptr_y = s->edge_emu_buffer;
 
326
        if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
 
327
            uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
 
328
            s->vdsp.emulated_edge_mc(uvbuf, ptr_cb,
 
329
                                     s->uvlinesize, s->uvlinesize,
 
330
                                     9, 9 + field_based,
 
331
                                     uvsrc_x, uvsrc_y << field_based,
 
332
                                     s->h_edge_pos >> 1, s->v_edge_pos >> 1);
 
333
            s->vdsp.emulated_edge_mc(uvbuf + 16, ptr_cr,
 
334
                                     s->uvlinesize, s->uvlinesize,
 
335
                                     9, 9 + field_based,
 
336
                                     uvsrc_x, uvsrc_y << field_based,
 
337
                                     s->h_edge_pos >> 1, s->v_edge_pos >> 1);
 
338
            ptr_cb = uvbuf;
 
339
            ptr_cr = uvbuf + 16;
 
340
        }
 
341
    }
 
342
 
 
343
    /* FIXME use this for field pix too instead of the obnoxious hack which
 
344
     * changes picture.data */
 
345
    if (bottom_field) {
 
346
        dest_y  += s->linesize;
 
347
        dest_cb += s->uvlinesize;
 
348
        dest_cr += s->uvlinesize;
 
349
    }
 
350
 
 
351
    if (field_select) {
 
352
        ptr_y  += s->linesize;
 
353
        ptr_cb += s->uvlinesize;
 
354
        ptr_cr += s->uvlinesize;
329
355
    }
330
356
 
331
357
    pix_op[0][dxy](dest_y, ptr_y, linesize, h);
332
358
 
333
 
    if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
334
 
        pix_op[s->chroma_x_shift][uvdxy]
335
 
                (dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
336
 
        pix_op[s->chroma_x_shift][uvdxy]
337
 
                (dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
 
359
    if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
 
360
        pix_op[s->chroma_x_shift][uvdxy]
 
361
            (dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
 
362
        pix_op[s->chroma_x_shift][uvdxy]
 
363
            (dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
338
364
    }
339
 
    if(!is_mpeg12 && (CONFIG_H261_ENCODER || CONFIG_H261_DECODER) &&
340
 
         s->out_format == FMT_H261){
 
365
    if (!is_mpeg12 && (CONFIG_H261_ENCODER || CONFIG_H261_DECODER) &&
 
366
        s->out_format == FMT_H261) {
341
367
        ff_h261_loop_filter(s);
342
368
    }
343
369
}
349
375
                        int motion_x, int motion_y, int h, int mb_y)
350
376
{
351
377
#if !CONFIG_SMALL
352
 
    if(s->out_format == FMT_MPEG1)
 
378
    if (s->out_format == FMT_MPEG1)
353
379
        mpeg_motion_internal(s, dest_y, dest_cb, dest_cr, 0, 0,
354
 
                    field_select, ref_picture, pix_op,
355
 
                    motion_x, motion_y, h, 1, mb_y);
 
380
                             field_select, ref_picture, pix_op,
 
381
                             motion_x, motion_y, h, 1, mb_y);
356
382
    else
357
383
#endif
358
384
        mpeg_motion_internal(s, dest_y, dest_cb, dest_cr, 0, 0,
359
 
                    field_select, ref_picture, pix_op,
360
 
                    motion_x, motion_y, h, 0, mb_y);
 
385
                             field_select, ref_picture, pix_op,
 
386
                             motion_x, motion_y, h, 0, mb_y);
361
387
}
362
388
 
363
389
static void mpeg_motion_field(MpegEncContext *s, uint8_t *dest_y,
368
394
                              int motion_x, int motion_y, int h, int mb_y)
369
395
{
370
396
#if !CONFIG_SMALL
371
 
    if(s->out_format == FMT_MPEG1)
 
397
    if (s->out_format == FMT_MPEG1)
372
398
        mpeg_motion_internal(s, dest_y, dest_cb, dest_cr, 1,
373
 
                    bottom_field, field_select, ref_picture, pix_op,
374
 
                    motion_x, motion_y, h, 1, mb_y);
 
399
                             bottom_field, field_select, ref_picture, pix_op,
 
400
                             motion_x, motion_y, h, 1, mb_y);
375
401
    else
376
402
#endif
377
403
        mpeg_motion_internal(s, dest_y, dest_cb, dest_cr, 1,
378
 
                    bottom_field, field_select, ref_picture, pix_op,
379
 
                    motion_x, motion_y, h, 0, mb_y);
 
404
                             bottom_field, field_select, ref_picture, pix_op,
 
405
                             motion_x, motion_y, h, 0, mb_y);
380
406
}
381
407
 
382
 
//FIXME move to dsputil, avg variant, 16x16 version
383
 
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
 
408
// FIXME move to dsputil, avg variant, 16x16 version
 
409
static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride)
 
410
{
384
411
    int x;
385
 
    uint8_t * const top   = src[1];
386
 
    uint8_t * const left  = src[2];
387
 
    uint8_t * const mid   = src[0];
388
 
    uint8_t * const right = src[3];
389
 
    uint8_t * const bottom= src[4];
 
412
    uint8_t *const top    = src[1];
 
413
    uint8_t *const left   = src[2];
 
414
    uint8_t *const mid    = src[0];
 
415
    uint8_t *const right  = src[3];
 
416
    uint8_t *const bottom = src[4];
390
417
#define OBMC_FILTER(x, t, l, m, r, b)\
391
418
    dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
392
419
#define OBMC_FILTER4(x, t, l, m, r, b)\
395
422
    OBMC_FILTER(x  +stride, t, l, m, r, b);\
396
423
    OBMC_FILTER(x+1+stride, t, l, m, r, b);
397
424
 
398
 
    x=0;
399
 
    OBMC_FILTER (x  , 2, 2, 4, 0, 0);
400
 
    OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
401
 
    OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
402
 
    OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
403
 
    OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
404
 
    OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
405
 
    x+= stride;
406
 
    OBMC_FILTER (x  , 1, 2, 5, 0, 0);
407
 
    OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
408
 
    OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
409
 
    OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
410
 
    x+= stride;
411
 
    OBMC_FILTER4(x  , 1, 2, 5, 0, 0);
412
 
    OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
413
 
    OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
414
 
    OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
415
 
    x+= 2*stride;
416
 
    OBMC_FILTER4(x  , 0, 2, 5, 0, 1);
417
 
    OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
418
 
    OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
419
 
    OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
420
 
    x+= 2*stride;
421
 
    OBMC_FILTER (x  , 0, 2, 5, 0, 1);
422
 
    OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
423
 
    OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
424
 
    OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
425
 
    OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
426
 
    OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
427
 
    x+= stride;
428
 
    OBMC_FILTER (x  , 0, 2, 4, 0, 2);
429
 
    OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
430
 
    OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
431
 
    OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
 
425
    x = 0;
 
426
    OBMC_FILTER (x    , 2, 2, 4, 0, 0);
 
427
    OBMC_FILTER (x + 1, 2, 1, 5, 0, 0);
 
428
    OBMC_FILTER4(x + 2, 2, 1, 5, 0, 0);
 
429
    OBMC_FILTER4(x + 4, 2, 0, 5, 1, 0);
 
430
    OBMC_FILTER (x + 6, 2, 0, 5, 1, 0);
 
431
    OBMC_FILTER (x + 7, 2, 0, 4, 2, 0);
 
432
    x += stride;
 
433
    OBMC_FILTER (x    , 1, 2, 5, 0, 0);
 
434
    OBMC_FILTER (x + 1, 1, 2, 5, 0, 0);
 
435
    OBMC_FILTER (x + 6, 1, 0, 5, 2, 0);
 
436
    OBMC_FILTER (x + 7, 1, 0, 5, 2, 0);
 
437
    x += stride;
 
438
    OBMC_FILTER4(x    , 1, 2, 5, 0, 0);
 
439
    OBMC_FILTER4(x + 2, 1, 1, 6, 0, 0);
 
440
    OBMC_FILTER4(x + 4, 1, 0, 6, 1, 0);
 
441
    OBMC_FILTER4(x + 6, 1, 0, 5, 2, 0);
 
442
    x += 2 * stride;
 
443
    OBMC_FILTER4(x    , 0, 2, 5, 0, 1);
 
444
    OBMC_FILTER4(x + 2, 0, 1, 6, 0, 1);
 
445
    OBMC_FILTER4(x + 4, 0, 0, 6, 1, 1);
 
446
    OBMC_FILTER4(x + 6, 0, 0, 5, 2, 1);
 
447
    x += 2*stride;
 
448
    OBMC_FILTER (x    , 0, 2, 5, 0, 1);
 
449
    OBMC_FILTER (x + 1, 0, 2, 5, 0, 1);
 
450
    OBMC_FILTER4(x + 2, 0, 1, 5, 0, 2);
 
451
    OBMC_FILTER4(x + 4, 0, 0, 5, 1, 2);
 
452
    OBMC_FILTER (x + 6, 0, 0, 5, 2, 1);
 
453
    OBMC_FILTER (x + 7, 0, 0, 5, 2, 1);
 
454
    x += stride;
 
455
    OBMC_FILTER (x    , 0, 2, 4, 0, 2);
 
456
    OBMC_FILTER (x + 1, 0, 1, 5, 0, 2);
 
457
    OBMC_FILTER (x + 6, 0, 0, 5, 1, 2);
 
458
    OBMC_FILTER (x + 7, 0, 0, 4, 2, 2);
432
459
}
433
460
 
434
461
/* obmc for 1 8x8 luma block */
436
463
                               uint8_t *dest, uint8_t *src,
437
464
                               int src_x, int src_y,
438
465
                               op_pixels_func *pix_op,
439
 
                               int16_t mv[5][2]/* mid top left right bottom*/)
 
466
                               int16_t mv[5][2] /* mid top left right bottom */)
440
467
#define MID    0
441
468
{
442
469
    int i;
443
470
    uint8_t *ptr[5];
444
471
 
445
 
    av_assert2(s->quarter_sample==0);
 
472
    av_assert2(s->quarter_sample == 0);
446
473
 
447
 
    for(i=0; i<5; i++){
448
 
        if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
449
 
            ptr[i]= ptr[MID];
450
 
        }else{
451
 
            ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
452
 
            hpel_motion(s, ptr[i], src,
453
 
                        src_x, src_y,
454
 
                        pix_op,
 
474
    for (i = 0; i < 5; i++) {
 
475
        if (i && mv[i][0] == mv[MID][0] && mv[i][1] == mv[MID][1]) {
 
476
            ptr[i] = ptr[MID];
 
477
        } else {
 
478
            ptr[i] = s->obmc_scratchpad + 8 * (i & 1) +
 
479
                     s->linesize * 8 * (i >> 1);
 
480
            hpel_motion(s, ptr[i], src, src_x, src_y, pix_op,
455
481
                        mv[i][0], mv[i][1]);
456
482
        }
457
483
    }
460
486
}
461
487
 
462
488
static inline void qpel_motion(MpegEncContext *s,
463
 
                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
464
 
                               int field_based, int bottom_field, int field_select,
465
 
                               uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
 
489
                               uint8_t *dest_y,
 
490
                               uint8_t *dest_cb,
 
491
                               uint8_t *dest_cr,
 
492
                               int field_based, int bottom_field,
 
493
                               int field_select, uint8_t **ref_picture,
 
494
                               op_pixels_func (*pix_op)[4],
466
495
                               qpel_mc_func (*qpix_op)[16],
467
496
                               int motion_x, int motion_y, int h)
468
497
{
470
499
    int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos;
471
500
    ptrdiff_t linesize, uvlinesize;
472
501
 
473
 
    dxy = ((motion_y & 3) << 2) | (motion_x & 3);
 
502
    dxy   = ((motion_y & 3) << 2) | (motion_x & 3);
 
503
 
474
504
    src_x = s->mb_x *  16                 + (motion_x >> 2);
475
505
    src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
476
506
 
477
507
    v_edge_pos = s->v_edge_pos >> field_based;
478
 
    linesize = s->linesize << field_based;
 
508
    linesize   = s->linesize   << field_based;
479
509
    uvlinesize = s->uvlinesize << field_based;
480
510
 
481
 
    if(field_based){
482
 
        mx= motion_x/2;
483
 
        my= motion_y>>1;
484
 
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
485
 
        static const int rtab[8]= {0,0,1,1,0,0,0,1};
486
 
        mx= (motion_x>>1) + rtab[motion_x&7];
487
 
        my= (motion_y>>1) + rtab[motion_y&7];
488
 
    }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
489
 
        mx= (motion_x>>1)|(motion_x&1);
490
 
        my= (motion_y>>1)|(motion_y&1);
491
 
    }else{
492
 
        mx= motion_x/2;
493
 
        my= motion_y/2;
 
511
    if (field_based) {
 
512
        mx = motion_x / 2;
 
513
        my = motion_y >> 1;
 
514
    } else if (s->workaround_bugs & FF_BUG_QPEL_CHROMA2) {
 
515
        static const int rtab[8] = { 0, 0, 1, 1, 0, 0, 0, 1 };
 
516
        mx = (motion_x >> 1) + rtab[motion_x & 7];
 
517
        my = (motion_y >> 1) + rtab[motion_y & 7];
 
518
    } else if (s->workaround_bugs & FF_BUG_QPEL_CHROMA) {
 
519
        mx = (motion_x >> 1) | (motion_x & 1);
 
520
        my = (motion_y >> 1) | (motion_y & 1);
 
521
    } else {
 
522
        mx = motion_x / 2;
 
523
        my = motion_y / 2;
494
524
    }
495
 
    mx= (mx>>1)|(mx&1);
496
 
    my= (my>>1)|(my&1);
 
525
    mx = (mx >> 1) | (mx & 1);
 
526
    my = (my >> 1) | (my & 1);
497
527
 
498
 
    uvdxy= (mx&1) | ((my&1)<<1);
499
 
    mx>>=1;
500
 
    my>>=1;
 
528
    uvdxy = (mx & 1) | ((my & 1) << 1);
 
529
    mx  >>= 1;
 
530
    my  >>= 1;
501
531
 
502
532
    uvsrc_x = s->mb_x *  8                 + mx;
503
533
    uvsrc_y = s->mb_y * (8 >> field_based) + my;
504
534
 
505
 
    ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;
 
535
    ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
506
536
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
507
537
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
508
538
 
509
 
    if(   (unsigned)src_x > FFMAX(s->h_edge_pos - (motion_x&3) - 16, 0)
510
 
       || (unsigned)src_y > FFMAX(   v_edge_pos - (motion_y&3) - h , 0)){
511
 
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize,
512
 
                                 ptr_y, s->linesize,
513
 
                                 17, 17+field_based, src_x, src_y<<field_based,
 
539
    if ((unsigned)src_x > FFMAX(s->h_edge_pos - (motion_x & 3) - 16, 0) ||
 
540
        (unsigned)src_y > FFMAX(   v_edge_pos - (motion_y & 3) - h, 0)) {
 
541
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
 
542
                                 s->linesize, s->linesize,
 
543
                                 17, 17 + field_based,
 
544
                                 src_x, src_y << field_based,
514
545
                                 s->h_edge_pos, s->v_edge_pos);
515
 
        ptr_y= s->edge_emu_buffer;
516
 
        if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
517
 
            uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
518
 
            s->vdsp.emulated_edge_mc(uvbuf, s->uvlinesize,
519
 
                                     ptr_cb, s->uvlinesize,
520
 
                                     9, 9 + field_based,
521
 
                                     uvsrc_x, uvsrc_y<<field_based,
522
 
                                     s->h_edge_pos>>1, s->v_edge_pos>>1);
523
 
            s->vdsp.emulated_edge_mc(uvbuf + 16, s->uvlinesize,
524
 
                                     ptr_cr, s->uvlinesize,
525
 
                                     9, 9 + field_based,
526
 
                                     uvsrc_x, uvsrc_y<<field_based,
527
 
                                     s->h_edge_pos>>1, s->v_edge_pos>>1);
528
 
            ptr_cb= uvbuf;
529
 
            ptr_cr= uvbuf + 16;
 
546
        ptr_y = s->edge_emu_buffer;
 
547
        if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
 
548
            uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
 
549
            s->vdsp.emulated_edge_mc(uvbuf, ptr_cb,
 
550
                                     s->uvlinesize, s->uvlinesize,
 
551
                                     9, 9 + field_based,
 
552
                                     uvsrc_x, uvsrc_y << field_based,
 
553
                                     s->h_edge_pos >> 1, s->v_edge_pos >> 1);
 
554
            s->vdsp.emulated_edge_mc(uvbuf + 16, ptr_cr,
 
555
                                     s->uvlinesize, s->uvlinesize,
 
556
                                     9, 9 + field_based,
 
557
                                     uvsrc_x, uvsrc_y << field_based,
 
558
                                     s->h_edge_pos >> 1, s->v_edge_pos >> 1);
 
559
            ptr_cb = uvbuf;
 
560
            ptr_cr = uvbuf + 16;
530
561
        }
531
562
    }
532
563
 
533
 
    if(!field_based)
 
564
    if (!field_based)
534
565
        qpix_op[0][dxy](dest_y, ptr_y, linesize);
535
 
    else{
536
 
        if(bottom_field){
537
 
            dest_y += s->linesize;
538
 
            dest_cb+= s->uvlinesize;
539
 
            dest_cr+= s->uvlinesize;
 
566
    else {
 
567
        if (bottom_field) {
 
568
            dest_y  += s->linesize;
 
569
            dest_cb += s->uvlinesize;
 
570
            dest_cr += s->uvlinesize;
540
571
        }
541
572
 
542
 
        if(field_select){
 
573
        if (field_select) {
543
574
            ptr_y  += s->linesize;
544
575
            ptr_cb += s->uvlinesize;
545
576
            ptr_cr += s->uvlinesize;
546
577
        }
547
 
        //damn interlaced mode
548
 
        //FIXME boundary mirroring is not exactly correct here
549
 
        qpix_op[1][dxy](dest_y  , ptr_y  , linesize);
550
 
        qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
 
578
        // damn interlaced mode
 
579
        // FIXME boundary mirroring is not exactly correct here
 
580
        qpix_op[1][dxy](dest_y, ptr_y, linesize);
 
581
        qpix_op[1][dxy](dest_y + 8, ptr_y + 8, linesize);
551
582
    }
552
 
    if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
 
583
    if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
553
584
        pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
554
585
        pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
555
586
    }
564
595
                              op_pixels_func *pix_op,
565
596
                              int mx, int my)
566
597
{
567
 
    int dxy, emu=0, src_x, src_y;
 
598
    uint8_t *ptr;
 
599
    int src_x, src_y, dxy, emu = 0;
568
600
    ptrdiff_t offset;
569
 
    uint8_t *ptr;
570
601
 
571
602
    /* In case of 8X8, we construct a single chroma motion vector
572
 
       with a special rounding */
573
 
    mx= ff_h263_round_chroma(mx);
574
 
    my= ff_h263_round_chroma(my);
 
603
     * with a special rounding */
 
604
    mx = ff_h263_round_chroma(mx);
 
605
    my = ff_h263_round_chroma(my);
575
606
 
576
 
    dxy = ((my & 1) << 1) | (mx & 1);
 
607
    dxy  = ((my & 1) << 1) | (mx & 1);
577
608
    mx >>= 1;
578
609
    my >>= 1;
579
610
 
587
618
        dxy &= ~2;
588
619
 
589
620
    offset = src_y * s->uvlinesize + src_x;
590
 
    ptr = ref_picture[1] + offset;
591
 
    if(s->flags&CODEC_FLAG_EMU_EDGE){
592
 
        if(   (unsigned)src_x > FFMAX((s->h_edge_pos>>1) - (dxy &1) - 8, 0)
593
 
           || (unsigned)src_y > FFMAX((s->v_edge_pos>>1) - (dxy>>1) - 8, 0)){
594
 
            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->uvlinesize,
595
 
                                     ptr, s->uvlinesize, 9, 9, src_x, src_y,
596
 
                                     s->h_edge_pos>>1, s->v_edge_pos>>1);
597
 
            ptr= s->edge_emu_buffer;
598
 
            emu=1;
 
621
    ptr    = ref_picture[1] + offset;
 
622
    if (s->flags & CODEC_FLAG_EMU_EDGE) {
 
623
        if ((unsigned)src_x > FFMAX((s->h_edge_pos >> 1) - (dxy & 1) - 8, 0) ||
 
624
            (unsigned)src_y > FFMAX((s->v_edge_pos >> 1) - (dxy >> 1) - 8, 0)) {
 
625
            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
 
626
                                     s->uvlinesize, s->uvlinesize,
 
627
                                     9, 9, src_x, src_y,
 
628
                                     s->h_edge_pos >> 1, s->v_edge_pos >> 1);
 
629
            ptr = s->edge_emu_buffer;
 
630
            emu = 1;
599
631
        }
600
632
    }
601
633
    pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
602
634
 
603
635
    ptr = ref_picture[2] + offset;
604
 
    if(emu){
605
 
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->uvlinesize,
606
 
                                 ptr, s->uvlinesize, 9, 9, src_x, src_y,
607
 
                                 s->h_edge_pos>>1, s->v_edge_pos>>1);
608
 
        ptr= s->edge_emu_buffer;
 
636
    if (emu) {
 
637
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
 
638
                                 s->uvlinesize, s->uvlinesize,
 
639
                                 9, 9, src_x, src_y,
 
640
                                 s->h_edge_pos >> 1, s->v_edge_pos >> 1);
 
641
        ptr = s->edge_emu_buffer;
609
642
    }
610
643
    pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
611
644
}
612
645
 
613
 
static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){
 
646
static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir)
 
647
{
614
648
    /* fetch pixels for estimated mv 4 macroblocks ahead
615
649
     * optimized for 64byte cache lines */
616
650
    const int shift = s->quarter_sample ? 2 : 1;
617
 
    const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
618
 
    const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
619
 
    int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
620
 
    s->vdsp.prefetch(pix[0]+off, s->linesize, 4);
621
 
    off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
622
 
    s->vdsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
 
651
    const int mx    = (s->mv[dir][0][0] >> shift) + 16 * s->mb_x + 8;
 
652
    const int my    = (s->mv[dir][0][1] >> shift) + 16 * s->mb_y;
 
653
    int off         = mx + (my + (s->mb_x & 3) * 4) * s->linesize + 64;
 
654
 
 
655
    s->vdsp.prefetch(pix[0] + off, s->linesize, 4);
 
656
    off = (mx >> 1) + ((my >> 1) + (s->mb_x & 7)) * s->uvlinesize + 64;
 
657
    s->vdsp.prefetch(pix[1] + off, pix[2] - pix[1], 2);
 
658
}
 
659
 
 
660
static inline void apply_obmc(MpegEncContext *s,
 
661
                              uint8_t *dest_y,
 
662
                              uint8_t *dest_cb,
 
663
                              uint8_t *dest_cr,
 
664
                              uint8_t **ref_picture,
 
665
                              op_pixels_func (*pix_op)[4])
 
666
{
 
667
    LOCAL_ALIGNED_8(int16_t, mv_cache, [4], [4][2]);
 
668
    Picture *cur_frame   = &s->current_picture;
 
669
    int mb_x = s->mb_x;
 
670
    int mb_y = s->mb_y;
 
671
    const int xy         = mb_x + mb_y * s->mb_stride;
 
672
    const int mot_stride = s->b8_stride;
 
673
    const int mot_xy     = mb_x * 2 + mb_y * 2 * mot_stride;
 
674
    int mx, my, i;
 
675
 
 
676
    av_assert2(!s->mb_skipped);
 
677
 
 
678
    AV_COPY32(mv_cache[1][1], cur_frame->motion_val[0][mot_xy]);
 
679
    AV_COPY32(mv_cache[1][2], cur_frame->motion_val[0][mot_xy + 1]);
 
680
 
 
681
    AV_COPY32(mv_cache[2][1],
 
682
              cur_frame->motion_val[0][mot_xy + mot_stride]);
 
683
    AV_COPY32(mv_cache[2][2],
 
684
              cur_frame->motion_val[0][mot_xy + mot_stride + 1]);
 
685
 
 
686
    AV_COPY32(mv_cache[3][1],
 
687
              cur_frame->motion_val[0][mot_xy + mot_stride]);
 
688
    AV_COPY32(mv_cache[3][2],
 
689
              cur_frame->motion_val[0][mot_xy + mot_stride + 1]);
 
690
 
 
691
    if (mb_y == 0 || IS_INTRA(cur_frame->mb_type[xy - s->mb_stride])) {
 
692
        AV_COPY32(mv_cache[0][1], mv_cache[1][1]);
 
693
        AV_COPY32(mv_cache[0][2], mv_cache[1][2]);
 
694
    } else {
 
695
        AV_COPY32(mv_cache[0][1],
 
696
                  cur_frame->motion_val[0][mot_xy - mot_stride]);
 
697
        AV_COPY32(mv_cache[0][2],
 
698
                  cur_frame->motion_val[0][mot_xy - mot_stride + 1]);
 
699
    }
 
700
 
 
701
    if (mb_x == 0 || IS_INTRA(cur_frame->mb_type[xy - 1])) {
 
702
        AV_COPY32(mv_cache[1][0], mv_cache[1][1]);
 
703
        AV_COPY32(mv_cache[2][0], mv_cache[2][1]);
 
704
    } else {
 
705
        AV_COPY32(mv_cache[1][0], cur_frame->motion_val[0][mot_xy - 1]);
 
706
        AV_COPY32(mv_cache[2][0],
 
707
                  cur_frame->motion_val[0][mot_xy - 1 + mot_stride]);
 
708
    }
 
709
 
 
710
    if (mb_x + 1 >= s->mb_width || IS_INTRA(cur_frame->mb_type[xy + 1])) {
 
711
        AV_COPY32(mv_cache[1][3], mv_cache[1][2]);
 
712
        AV_COPY32(mv_cache[2][3], mv_cache[2][2]);
 
713
    } else {
 
714
        AV_COPY32(mv_cache[1][3], cur_frame->motion_val[0][mot_xy + 2]);
 
715
        AV_COPY32(mv_cache[2][3],
 
716
                  cur_frame->motion_val[0][mot_xy + 2 + mot_stride]);
 
717
    }
 
718
 
 
719
    mx = 0;
 
720
    my = 0;
 
721
    for (i = 0; i < 4; i++) {
 
722
        const int x      = (i & 1) + 1;
 
723
        const int y      = (i >> 1) + 1;
 
724
        int16_t mv[5][2] = {
 
725
            { mv_cache[y][x][0],     mv_cache[y][x][1]         },
 
726
            { mv_cache[y - 1][x][0], mv_cache[y - 1][x][1]     },
 
727
            { mv_cache[y][x - 1][0], mv_cache[y][x - 1][1]     },
 
728
            { mv_cache[y][x + 1][0], mv_cache[y][x + 1][1]     },
 
729
            { mv_cache[y + 1][x][0], mv_cache[y + 1][x][1]     }
 
730
        };
 
731
        // FIXME cleanup
 
732
        obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
 
733
                    ref_picture[0],
 
734
                    mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >> 1) * 8,
 
735
                    pix_op[1],
 
736
                    mv);
 
737
 
 
738
        mx += mv[0][0];
 
739
        my += mv[0][1];
 
740
    }
 
741
    if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
 
742
        chroma_4mv_motion(s, dest_cb, dest_cr,
 
743
                          ref_picture, pix_op[1],
 
744
                          mx, my);
 
745
}
 
746
 
 
747
static inline void apply_8x8(MpegEncContext *s,
 
748
                             uint8_t *dest_y,
 
749
                             uint8_t *dest_cb,
 
750
                             uint8_t *dest_cr,
 
751
                             int dir,
 
752
                             uint8_t **ref_picture,
 
753
                             qpel_mc_func (*qpix_op)[16],
 
754
                             op_pixels_func (*pix_op)[4])
 
755
{
 
756
    int dxy, mx, my, src_x, src_y;
 
757
    int i;
 
758
    int mb_x = s->mb_x;
 
759
    int mb_y = s->mb_y;
 
760
    uint8_t *ptr, *dest;
 
761
 
 
762
    mx = 0;
 
763
    my = 0;
 
764
    if (s->quarter_sample) {
 
765
        for (i = 0; i < 4; i++) {
 
766
            int motion_x = s->mv[dir][i][0];
 
767
            int motion_y = s->mv[dir][i][1];
 
768
 
 
769
            dxy   = ((motion_y & 3) << 2) | (motion_x & 3);
 
770
            src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
 
771
            src_y = mb_y * 16 + (motion_y >> 2) + (i >> 1) * 8;
 
772
 
 
773
            /* WARNING: do no forget half pels */
 
774
            src_x = av_clip(src_x, -16, s->width);
 
775
            if (src_x == s->width)
 
776
                dxy &= ~3;
 
777
            src_y = av_clip(src_y, -16, s->height);
 
778
            if (src_y == s->height)
 
779
                dxy &= ~12;
 
780
 
 
781
            ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
 
782
            if (s->flags & CODEC_FLAG_EMU_EDGE) {
 
783
                if ((unsigned)src_x > FFMAX(s->h_edge_pos - (motion_x & 3) - 8, 0) ||
 
784
                    (unsigned)src_y > FFMAX(s->v_edge_pos - (motion_y & 3) - 8, 0)) {
 
785
                    s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
 
786
                                             s->linesize, s->linesize,
 
787
                                             9, 9,
 
788
                                             src_x, src_y,
 
789
                                             s->h_edge_pos,
 
790
                                             s->v_edge_pos);
 
791
                    ptr = s->edge_emu_buffer;
 
792
                }
 
793
            }
 
794
            dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
 
795
            qpix_op[1][dxy](dest, ptr, s->linesize);
 
796
 
 
797
            mx += s->mv[dir][i][0] / 2;
 
798
            my += s->mv[dir][i][1] / 2;
 
799
        }
 
800
    } else {
 
801
        for (i = 0; i < 4; i++) {
 
802
            hpel_motion(s,
 
803
                        dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
 
804
                        ref_picture[0],
 
805
                        mb_x * 16 + (i & 1) * 8,
 
806
                        mb_y * 16 + (i >> 1) * 8,
 
807
                        pix_op[1],
 
808
                        s->mv[dir][i][0],
 
809
                        s->mv[dir][i][1]);
 
810
 
 
811
            mx += s->mv[dir][i][0];
 
812
            my += s->mv[dir][i][1];
 
813
        }
 
814
    }
 
815
 
 
816
    if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
 
817
        chroma_4mv_motion(s, dest_cb, dest_cr,
 
818
                          ref_picture, pix_op[1], mx, my);
623
819
}
624
820
 
625
821
/**
635
831
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
636
832
 */
637
833
static av_always_inline void MPV_motion_internal(MpegEncContext *s,
638
 
                              uint8_t *dest_y, uint8_t *dest_cb,
639
 
                              uint8_t *dest_cr, int dir,
640
 
                              uint8_t **ref_picture,
641
 
                              op_pixels_func (*pix_op)[4],
642
 
                              qpel_mc_func (*qpix_op)[16], int is_mpeg12)
 
834
                                                 uint8_t *dest_y,
 
835
                                                 uint8_t *dest_cb,
 
836
                                                 uint8_t *dest_cr,
 
837
                                                 int dir,
 
838
                                                 uint8_t **ref_picture,
 
839
                                                 op_pixels_func (*pix_op)[4],
 
840
                                                 qpel_mc_func (*qpix_op)[16],
 
841
                                                 int is_mpeg12)
643
842
{
644
 
    int dxy, mx, my, src_x, src_y, motion_x, motion_y;
645
 
    int mb_x, mb_y, i;
646
 
    uint8_t *ptr, *dest;
647
 
 
648
 
    mb_x = s->mb_x;
649
 
    mb_y = s->mb_y;
 
843
    int i;
 
844
    int mb_y = s->mb_y;
650
845
 
651
846
    prefetch_motion(s, ref_picture, dir);
652
847
 
653
 
    if(!is_mpeg12 && s->obmc && s->pict_type != AV_PICTURE_TYPE_B){
654
 
        LOCAL_ALIGNED_8(int16_t, mv_cache, [4], [4][2]);
655
 
        Picture *cur_frame = &s->current_picture;
656
 
        const int xy= s->mb_x + s->mb_y*s->mb_stride;
657
 
        const int mot_stride= s->b8_stride;
658
 
        const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
659
 
 
660
 
        av_assert2(!s->mb_skipped);
661
 
 
662
 
        AV_COPY32(mv_cache[1][1], cur_frame->motion_val[0][mot_xy    ]);
663
 
        AV_COPY32(mv_cache[1][2], cur_frame->motion_val[0][mot_xy + 1]);
664
 
 
665
 
        AV_COPY32(mv_cache[2][1], cur_frame->motion_val[0][mot_xy + mot_stride    ]);
666
 
        AV_COPY32(mv_cache[2][2], cur_frame->motion_val[0][mot_xy + mot_stride + 1]);
667
 
 
668
 
        AV_COPY32(mv_cache[3][1], cur_frame->motion_val[0][mot_xy + mot_stride    ]);
669
 
        AV_COPY32(mv_cache[3][2], cur_frame->motion_val[0][mot_xy + mot_stride + 1]);
670
 
 
671
 
        if (mb_y == 0 || IS_INTRA(cur_frame->mb_type[xy - s->mb_stride])) {
672
 
            AV_COPY32(mv_cache[0][1], mv_cache[1][1]);
673
 
            AV_COPY32(mv_cache[0][2], mv_cache[1][2]);
674
 
        }else{
675
 
            AV_COPY32(mv_cache[0][1], cur_frame->motion_val[0][mot_xy - mot_stride    ]);
676
 
            AV_COPY32(mv_cache[0][2], cur_frame->motion_val[0][mot_xy - mot_stride + 1]);
677
 
        }
678
 
 
679
 
        if (mb_x == 0 || IS_INTRA(cur_frame->mb_type[xy - 1])) {
680
 
            AV_COPY32(mv_cache[1][0], mv_cache[1][1]);
681
 
            AV_COPY32(mv_cache[2][0], mv_cache[2][1]);
682
 
        }else{
683
 
            AV_COPY32(mv_cache[1][0], cur_frame->motion_val[0][mot_xy - 1]);
684
 
            AV_COPY32(mv_cache[2][0], cur_frame->motion_val[0][mot_xy - 1 + mot_stride]);
685
 
        }
686
 
 
687
 
        if (mb_x + 1 >= s->mb_width || IS_INTRA(cur_frame->mb_type[xy + 1])) {
688
 
            AV_COPY32(mv_cache[1][3], mv_cache[1][2]);
689
 
            AV_COPY32(mv_cache[2][3], mv_cache[2][2]);
690
 
        }else{
691
 
            AV_COPY32(mv_cache[1][3], cur_frame->motion_val[0][mot_xy + 2]);
692
 
            AV_COPY32(mv_cache[2][3], cur_frame->motion_val[0][mot_xy + 2 + mot_stride]);
693
 
        }
694
 
 
695
 
        mx = 0;
696
 
        my = 0;
697
 
        for(i=0;i<4;i++) {
698
 
            const int x= (i&1)+1;
699
 
            const int y= (i>>1)+1;
700
 
            int16_t mv[5][2]= {
701
 
                {mv_cache[y][x  ][0], mv_cache[y][x  ][1]},
702
 
                {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
703
 
                {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
704
 
                {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
705
 
                {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
706
 
            //FIXME cleanup
707
 
            obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
708
 
                        ref_picture[0],
709
 
                        mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
710
 
                        pix_op[1],
711
 
                        mv);
712
 
 
713
 
            mx += mv[0][0];
714
 
            my += mv[0][1];
715
 
        }
716
 
        if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
717
 
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
718
 
 
 
848
    if (!is_mpeg12 && s->obmc && s->pict_type != AV_PICTURE_TYPE_B) {
 
849
        apply_obmc(s, dest_y, dest_cb, dest_cr, ref_picture, pix_op);
719
850
        return;
720
851
    }
721
852
 
722
 
    switch(s->mv_type) {
 
853
    switch (s->mv_type) {
723
854
    case MV_TYPE_16X16:
724
 
        if(s->mcsel){
725
 
            if(s->real_sprite_warping_points==1){
 
855
        if (s->mcsel) {
 
856
            if (s->real_sprite_warping_points == 1) {
726
857
                gmc1_motion(s, dest_y, dest_cb, dest_cr,
727
858
                            ref_picture);
728
 
            }else{
 
859
            } else {
729
860
                gmc_motion(s, dest_y, dest_cb, dest_cr,
730
 
                            ref_picture);
 
861
                           ref_picture);
731
862
            }
732
 
        }else if(!is_mpeg12 && s->quarter_sample){
 
863
        } else if (!is_mpeg12 && s->quarter_sample) {
733
864
            qpel_motion(s, dest_y, dest_cb, dest_cr,
734
865
                        0, 0, 0,
735
866
                        ref_picture, pix_op, qpix_op,
737
868
        } else if (!is_mpeg12 && (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) &&
738
869
                   s->mspel && s->codec_id == AV_CODEC_ID_WMV2) {
739
870
            ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
740
 
                        ref_picture, pix_op,
741
 
                        s->mv[dir][0][0], s->mv[dir][0][1], 16);
742
 
        }else
743
 
        {
 
871
                            ref_picture, pix_op,
 
872
                            s->mv[dir][0][0], s->mv[dir][0][1], 16);
 
873
        } else {
744
874
            mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
745
875
                        ref_picture, pix_op,
746
876
                        s->mv[dir][0][0], s->mv[dir][0][1], 16, mb_y);
747
877
        }
748
878
        break;
749
879
    case MV_TYPE_8X8:
750
 
    if (!is_mpeg12) {
751
 
        mx = 0;
752
 
        my = 0;
753
 
        if(s->quarter_sample){
754
 
            for(i=0;i<4;i++) {
755
 
                motion_x = s->mv[dir][i][0];
756
 
                motion_y = s->mv[dir][i][1];
757
 
 
758
 
                dxy = ((motion_y & 3) << 2) | (motion_x & 3);
759
 
                src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
760
 
                src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
761
 
 
762
 
                /* WARNING: do no forget half pels */
763
 
                src_x = av_clip(src_x, -16, s->width);
764
 
                if (src_x == s->width)
765
 
                    dxy &= ~3;
766
 
                src_y = av_clip(src_y, -16, s->height);
767
 
                if (src_y == s->height)
768
 
                    dxy &= ~12;
769
 
 
770
 
                ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
771
 
                if(s->flags&CODEC_FLAG_EMU_EDGE){
772
 
                    if(   (unsigned)src_x > FFMAX(s->h_edge_pos - (motion_x&3) - 8, 0)
773
 
                       || (unsigned)src_y > FFMAX(s->v_edge_pos - (motion_y&3) - 8, 0)){
774
 
                        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, s->linesize,
775
 
                                                 ptr, s->linesize, 9, 9,
776
 
                                                 src_x, src_y,
777
 
                                                 s->h_edge_pos, s->v_edge_pos);
778
 
                        ptr= s->edge_emu_buffer;
779
 
                    }
780
 
                }
781
 
                dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
782
 
                qpix_op[1][dxy](dest, ptr, s->linesize);
783
 
 
784
 
                mx += s->mv[dir][i][0]/2;
785
 
                my += s->mv[dir][i][1]/2;
786
 
            }
787
 
        }else{
788
 
            for(i=0;i<4;i++) {
789
 
                hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
790
 
                            ref_picture[0],
791
 
                            mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
792
 
                            pix_op[1],
793
 
                            s->mv[dir][i][0], s->mv[dir][i][1]);
794
 
 
795
 
                mx += s->mv[dir][i][0];
796
 
                my += s->mv[dir][i][1];
797
 
            }
798
 
        }
799
 
 
800
 
        if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
801
 
            chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
802
 
    }
 
880
        if (!is_mpeg12)
 
881
            apply_8x8(s, dest_y, dest_cb, dest_cr,
 
882
                      dir, ref_picture, qpix_op, pix_op);
803
883
        break;
804
884
    case MV_TYPE_FIELD:
805
885
        if (s->picture_structure == PICT_FRAME) {
806
 
            if(!is_mpeg12 && s->quarter_sample){
807
 
                for(i=0; i<2; i++){
 
886
            if (!is_mpeg12 && s->quarter_sample) {
 
887
                for (i = 0; i < 2; i++)
808
888
                    qpel_motion(s, dest_y, dest_cb, dest_cr,
809
889
                                1, i, s->field_select[dir][i],
810
890
                                ref_picture, pix_op, qpix_op,
811
891
                                s->mv[dir][i][0], s->mv[dir][i][1], 8);
812
 
                }
813
 
            }else{
 
892
            } else {
814
893
                /* top field */
815
894
                mpeg_motion_field(s, dest_y, dest_cb, dest_cr,
816
895
                                  0, s->field_select[dir][0],
823
902
                                  s->mv[dir][1][0], s->mv[dir][1][1], 8, mb_y);
824
903
            }
825
904
        } else {
826
 
            if(   s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field
827
 
               || !ref_picture[0]){
 
905
            if (   s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field
 
906
                || !ref_picture[0]) {
828
907
                ref_picture = s->current_picture_ptr->f.data;
829
908
            }
830
909
 
831
910
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
832
911
                        s->field_select[dir][0],
833
912
                        ref_picture, pix_op,
834
 
                        s->mv[dir][0][0], s->mv[dir][0][1], 16, mb_y>>1);
 
913
                        s->mv[dir][0][0], s->mv[dir][0][1], 16, mb_y >> 1);
835
914
        }
836
915
        break;
837
916
    case MV_TYPE_16X8:
838
 
        for(i=0; i<2; i++){
839
 
            uint8_t ** ref2picture;
 
917
        for (i = 0; i < 2; i++) {
 
918
            uint8_t **ref2picture;
840
919
 
841
 
            if((s->picture_structure == s->field_select[dir][i] + 1
842
 
               || s->pict_type == AV_PICTURE_TYPE_B || s->first_field) && ref_picture[0]){
843
 
                ref2picture= ref_picture;
844
 
            }else{
 
920
            if ((s->picture_structure == s->field_select[dir][i] + 1
 
921
                || s->pict_type == AV_PICTURE_TYPE_B || s->first_field) && ref_picture[0]) {
 
922
                ref2picture = ref_picture;
 
923
            } else {
845
924
                ref2picture = s->current_picture_ptr->f.data;
846
925
            }
847
926
 
848
927
            mpeg_motion(s, dest_y, dest_cb, dest_cr,
849
928
                        s->field_select[dir][i],
850
929
                        ref2picture, pix_op,
851
 
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8, mb_y>>1);
 
930
                        s->mv[dir][i][0], s->mv[dir][i][1] + 16 * i,
 
931
                        8, mb_y >> 1);
852
932
 
853
 
            dest_y += 16*s->linesize;
854
 
            dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
855
 
            dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
 
933
            dest_y  += 16 * s->linesize;
 
934
            dest_cb += (16 >> s->chroma_y_shift) * s->uvlinesize;
 
935
            dest_cr += (16 >> s->chroma_y_shift) * s->uvlinesize;
856
936
        }
857
937
        break;
858
938
    case MV_TYPE_DMV:
859
 
        if(s->picture_structure == PICT_FRAME){
860
 
            for(i=0; i<2; i++){
 
939
        if (s->picture_structure == PICT_FRAME) {
 
940
            for (i = 0; i < 2; i++) {
861
941
                int j;
862
 
                for(j=0; j<2; j++){
 
942
                for (j = 0; j < 2; j++)
863
943
                    mpeg_motion_field(s, dest_y, dest_cb, dest_cr,
864
 
                                      j, j^i, ref_picture, pix_op,
865
 
                                      s->mv[dir][2*i + j][0],
866
 
                                      s->mv[dir][2*i + j][1], 8, mb_y);
867
 
                }
 
944
                                      j, j ^ i, ref_picture, pix_op,
 
945
                                      s->mv[dir][2 * i + j][0],
 
946
                                      s->mv[dir][2 * i + j][1], 8, mb_y);
868
947
                pix_op = s->hdsp.avg_pixels_tab;
869
948
            }
870
 
        }else{
 
949
        } else {
871
950
            if (!ref_picture[0]) {
872
951
                ref_picture = s->current_picture_ptr->f.data;
873
952
            }
874
 
            for(i=0; i<2; i++){
 
953
            for (i = 0; i < 2; i++) {
875
954
                mpeg_motion(s, dest_y, dest_cb, dest_cr,
876
 
                            s->picture_structure != i+1,
 
955
                            s->picture_structure != i + 1,
877
956
                            ref_picture, pix_op,
878
 
                            s->mv[dir][2*i][0],s->mv[dir][2*i][1],16, mb_y>>1);
 
957
                            s->mv[dir][2 * i][0], s->mv[dir][2 * i][1],
 
958
                            16, mb_y >> 1);
879
959
 
880
960
                // after put we make avg of the same block
881
 
                pix_op=s->hdsp.avg_pixels_tab;
 
961
                pix_op = s->hdsp.avg_pixels_tab;
882
962
 
883
 
                //opposite parity is always in the same frame if this is second field
884
 
                if(!s->first_field){
 
963
                /* opposite parity is always in the same frame if this is
 
964
                 * second field */
 
965
                if (!s->first_field) {
885
966
                    ref_picture = s->current_picture_ptr->f.data;
886
967
                }
887
968
            }
888
969
        }
889
 
    break;
 
970
        break;
890
971
    default: av_assert2(0);
891
972
    }
892
973
}
899
980
                   qpel_mc_func (*qpix_op)[16])
900
981
{
901
982
#if !CONFIG_SMALL
902
 
    if(s->out_format == FMT_MPEG1)
 
983
    if (s->out_format == FMT_MPEG1)
903
984
        MPV_motion_internal(s, dest_y, dest_cb, dest_cr, dir,
904
985
                            ref_picture, pix_op, qpix_op, 1);
905
986
    else