← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/h264_mvpred.h

  • Committer: Gauvain Pocentek
  • Date: 2012-03-06 11:59:12 UTC
  • mfrom: (66.1.15 precise)
  • Revision ID: gauvain@pocentek.net-20120306115912-h9d6kt9j0l532oo5
http://bugs.debian.org/442181
http://bugs.debian.org/481807
http://bugs.debian.org/496106
http://bugs.debian.org/533546
http://bugs.debian.org/568514
http://bugs.debian.org/637077
http://bugs.debian.org/638408
http://bugs.debian.org/643621
http://bugs.debian.org/650339
http://bugs.debian.org/653887
http://bugs.debian.org/654974
* Merge from Ubuntu:
  - put back faac support
  - recommends apport-hooks-medibuntu
  - change Maintainer, Uploaders & Vcs-* fields.
* New upstream snapshot
* upload to unstable
* Build against external libmpeg2
* drop 51_FTBFS_arm.patch again
* no longer build depend on libcdparanoia-dev on the Hurd
* Fix FTBFS on the hurd.
  Thanks to Samuel Thibault <sthibault@debian.org> (Closes: #654974)
* Fix FTBFS on arm
* New upstream snapshot, Closes: #650339, #643621, #481807
* Imported Upstream version 1.0~rc4+svn34492
* Bump standards version
* Bump dependency on libav >= 4:0.8~, Closes: #653887
* Fix build-indep
* Build mplayer-gui again, Closes: #568514
* Drop debian/all-lang-config-mak.sh, no longer needed
* include .dfsg1 in version number
* remove get-orig-source target
* no longer prune compiler flags from the environment
* No longer advertise nor build 3fdx, mga and dxr3 backends,
  Closes: #496106, #442181, #533546
* beautify mplayer version identification string
* Brown paperbag upload.
* Next try to fix build failure on sparce after recent binutils change.
* Brown paperbag upload.
* Really fix build failure on sparc after recent binutils change.
* Properly set Replaces/Conflicts on mplayer2{,-dbg} to avoid
  file overwrite errors.
* Adjust versioning of mplayer listed in the mplayer-dbg's Depends field.
* Fix build failure on sparc after recent binutils change.
* Urgency medium bumped because of RC-level bugfix
  and speeding up x264 transition.
* Update to my @debian.org email.
* Upload to unstable
* Enable joystick support on Linux only, Closes: #638408
* Rebuild fixes toolchain issue on arm, Closes: #637077
* New upstream snapshot
* following the discussion started by Diego Biurrun <diego@biurrun.de>
  in debian-devel, I have prepared a new packaging of 'mplayer'
  (with code that comes from CVS)
* the upstream tar.bz cannot be distributed by Debian, since it contains
   CSS code; so I am repackaging it 
* I have tried my best to address all known issues:
  - the package contains the detailed Copyright made by Diego Biurrun 
  - the package does not contain CSS code, or  AFAIK other code on which 
     there is active patent enforcement
  - there is a script  debian/cvs-changelog.sh  that shows all changes
     done to files included in this source.
    This should comply with GPLv2 sec 2.a  (in spirit if not in letter)
    For this reason, the source code contains CVS directories.
* needs   make (>= 3.80) for 'html-chunked-$(1)' in DOCS/xml/Makefile

* some corrections, as suggested Diego Biurrun
  - binary codecs should go into /usr/lib/codecs (upstream default)
  - better template 'mplayer/install_codecs'
  - an empty 'font=' in mplayer.conf breaks mplayer: postinst corrected
* correction in 'mplayer/cfgnote'
* better mplayer.postinst and mplayer.config

* New upstream release
* better debian/copyright file
* do not ship a skin
* New upstream release
* changed DEB_BUILD_OPTIONS to DEB_BUILD_CONFIGURE ,
  DEB_BUILD_OPTIONS is used as in debian policy
* use gcc-3.4
* changed xlibs-dev to a long list of dependencies, for Debian/etch
* try to adhere to  http://www.mplayerhq.hu/DOCS/tech/binary-packaging.txt
  (see README.Debian for details)
* removed dependency on xlibmesa-dev, disabled opengl
* New upstream release
* Simon McVittie <hacks@pseudorandom.co.uk> wonderful work:
- Work around Debian bug #267442 (glibc's sys/uio.h and gcc's altivec.h have
  conflicting uses for __vector) by re-ordering #includes
- Fix potential symlink attack in ./configure
- Disable support for binary codecs on platforms for which those codecs
  aren't available; also disable the corresponding Debconf note when it's
  inappropriate
- Changed Build-Depends: so it works in pbuilder
- Explicitly build-depend on libjpeg62-dev, libfontconfig1-dev,
  libungif4-dev 
- Tweak debian/rules to avoid certain errors being ignored
- Use --language=all
* provide a target  'debian/rules get-orig-source' 
  that recreates the orig.tar.gz ; then use the above orig.tar.gz
* rewrote some parts of debian/rules
* don't clean and recompile docs if upstream ships them
* mplayer-doc was shipping too much stuff
* translated man pages where not installed properly
* compile with libdv4-dev
* correct README.Debian
* Forgot build-dep on libtheora
* Must not depend on libxvidcore
* New upstream release
* new release.
* rc1 to become 0.90
* new pre-release
* new pre-release
* gtk bug fixed.
* new release.
* version bumped
* 0.60 pre2 release
* 0.60 pre-release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/h264_mvpred.h
35
35
//#undef NDEBUG
36
36
#include <assert.h>
37
37
 
38
 
static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){
 
38
static av_always_inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){
39
39
    const int topright_ref= h->ref_cache[list][ i - 8 + part_width ];
40
40
    MpegEncContext *s = &h->s;
41
41
 
48
48
                const int mb_type = mb_types[xy+(y4>>2)*s->mb_stride];\
49
49
                if(!USES_LIST(mb_type,list))\
50
50
                    return LIST_NOT_USED;\
51
 
                mv = s->current_picture_ptr->motion_val[list][h->mb2b_xy[xy]+3 + y4*h->b_stride];\
 
51
                mv = s->current_picture_ptr->f.motion_val[list][h->mb2b_xy[xy] + 3 + y4*h->b_stride];\
52
52
                h->mv_cache[list][scan8[0]-2][0] = mv[0];\
53
53
                h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\
54
 
                return s->current_picture_ptr->ref_index[list][4*xy+1 + (y4&~1)] REF_OP;
 
54
                return s->current_picture_ptr->f.ref_index[list][4*xy + 1 + (y4 & ~1)] REF_OP;
55
55
 
56
56
        if(topright_ref == PART_NOT_AVAILABLE
57
57
           && i >= scan8[0]+8 && (i&7)==4
58
58
           && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){
59
 
            const uint32_t *mb_types = s->current_picture_ptr->mb_type;
 
59
            const uint32_t *mb_types = s->current_picture_ptr->f.mb_type;
60
60
            const int16_t *mv;
61
61
            AV_ZERO32(h->mv_cache[list][scan8[0]-2]);
62
62
            *C = h->mv_cache[list][scan8[0]-2];
64
64
            if(!MB_FIELD
65
65
               && IS_INTERLACED(h->left_type[0])){
66
66
                SET_DIAG_MV(*2, >>1, h->left_mb_xy[0]+s->mb_stride, (s->mb_y&1)*2+(i>>5));
67
 
                assert(h->left_mb_xy[0] == h->left_mb_xy[1]);
68
67
            }
69
68
            if(MB_FIELD
70
69
               && !IS_INTERLACED(h->left_type[0])){
87
86
}
88
87
 
89
88
/**
90
 
 * gets the predicted MV.
 
89
 * Get the predicted MV.
91
90
 * @param n the block index
92
91
 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
93
92
 * @param mx the x component of the predicted motion vector
94
93
 * @param my the y component of the predicted motion vector
95
94
 */
96
 
static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){
 
95
static av_always_inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){
97
96
    const int index8= scan8[n];
98
97
    const int top_ref=      h->ref_cache[list][ index8 - 8 ];
99
98
    const int left_ref=     h->ref_cache[list][ index8 - 1 ];
143
142
}
144
143
 
145
144
/**
146
 
 * gets the directionally predicted 16x8 MV.
 
145
 * Get the directionally predicted 16x8 MV.
147
146
 * @param n the block index
148
147
 * @param mx the x component of the predicted motion vector
149
148
 * @param my the y component of the predicted motion vector
150
149
 */
151
 
static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
 
150
static av_always_inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
152
151
    if(n==0){
153
152
        const int top_ref=      h->ref_cache[list][ scan8[0] - 8 ];
154
153
        const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ];
178
177
}
179
178
 
180
179
/**
181
 
 * gets the directionally predicted 8x16 MV.
 
180
 * Get the directionally predicted 8x16 MV.
182
181
 * @param n the block index
183
182
 * @param mx the x component of the predicted motion vector
184
183
 * @param my the y component of the predicted motion vector
185
184
 */
186
 
static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
 
185
static av_always_inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
187
186
    if(n==0){
188
187
        const int left_ref=      h->ref_cache[list][ scan8[0] - 1 ];
189
188
        const int16_t * const A=  h->mv_cache[list][ scan8[0] - 1 ];
214
213
    pred_motion(h, n, 2, list, ref, mx, my);
215
214
}
216
215
 
217
 
static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){
218
 
    const int top_ref = h->ref_cache[0][ scan8[0] - 8 ];
219
 
    const int left_ref= h->ref_cache[0][ scan8[0] - 1 ];
 
216
#define FIX_MV_MBAFF(type, refn, mvn, idx)\
 
217
    if(FRAME_MBAFF){\
 
218
        if(MB_FIELD){\
 
219
            if(!IS_INTERLACED(type)){\
 
220
                refn <<= 1;\
 
221
                AV_COPY32(mvbuf[idx], mvn);\
 
222
                mvbuf[idx][1] /= 2;\
 
223
                mvn = mvbuf[idx];\
 
224
            }\
 
225
        }else{\
 
226
            if(IS_INTERLACED(type)){\
 
227
                refn >>= 1;\
 
228
                AV_COPY32(mvbuf[idx], mvn);\
 
229
                mvbuf[idx][1] <<= 1;\
 
230
                mvn = mvbuf[idx];\
 
231
            }\
 
232
        }\
 
233
    }
 
234
 
 
235
static av_always_inline void pred_pskip_motion(H264Context * const h){
 
236
    DECLARE_ALIGNED(4, static const int16_t, zeromv)[2] = {0};
 
237
    DECLARE_ALIGNED(4, int16_t, mvbuf)[3][2];
 
238
    MpegEncContext * const s = &h->s;
 
239
    int8_t *ref      = s->current_picture.f.ref_index[0];
 
240
    int16_t (*mv)[2] = s->current_picture.f.motion_val[0];
 
241
    int top_ref, left_ref, diagonal_ref, match_count, mx, my;
 
242
    const int16_t *A, *B, *C;
 
243
    int b_stride = h->b_stride;
 
244
 
 
245
    fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);
 
246
 
 
247
    /* To avoid doing an entire fill_decode_caches, we inline the relevant parts here.
 
248
     * FIXME: this is a partial duplicate of the logic in fill_decode_caches, but it's
 
249
     * faster this way.  Is there a way to avoid this duplication?
 
250
     */
 
251
    if(USES_LIST(h->left_type[LTOP], 0)){
 
252
        left_ref = ref[4*h->left_mb_xy[LTOP] + 1 + (h->left_block[0]&~1)];
 
253
        A = mv[h->mb2b_xy[h->left_mb_xy[LTOP]] + 3 + b_stride*h->left_block[0]];
 
254
        FIX_MV_MBAFF(h->left_type[LTOP], left_ref, A, 0);
 
255
        if(!(left_ref | AV_RN32A(A))){
 
256
            goto zeromv;
 
257
        }
 
258
    }else if(h->left_type[LTOP]){
 
259
        left_ref = LIST_NOT_USED;
 
260
        A = zeromv;
 
261
    }else{
 
262
        goto zeromv;
 
263
    }
 
264
 
 
265
    if(USES_LIST(h->top_type, 0)){
 
266
        top_ref = ref[4*h->top_mb_xy + 2];
 
267
        B = mv[h->mb2b_xy[h->top_mb_xy] + 3*b_stride];
 
268
        FIX_MV_MBAFF(h->top_type, top_ref, B, 1);
 
269
        if(!(top_ref | AV_RN32A(B))){
 
270
            goto zeromv;
 
271
        }
 
272
    }else if(h->top_type){
 
273
        top_ref = LIST_NOT_USED;
 
274
        B = zeromv;
 
275
    }else{
 
276
        goto zeromv;
 
277
    }
220
278
 
221
279
    tprintf(h->s.avctx, "pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y);
222
280
 
223
 
    if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE
224
 
       || !( top_ref | AV_RN32A(h->mv_cache[0][ scan8[0] - 8 ]))
225
 
       || !(left_ref | AV_RN32A(h->mv_cache[0][ scan8[0] - 1 ]))){
226
 
 
227
 
        *mx = *my = 0;
228
 
        return;
229
 
    }
230
 
 
231
 
    pred_motion(h, 0, 4, 0, 0, mx, my);
232
 
 
233
 
    return;
 
281
    if(USES_LIST(h->topright_type, 0)){
 
282
        diagonal_ref = ref[4*h->topright_mb_xy + 2];
 
283
        C = mv[h->mb2b_xy[h->topright_mb_xy] + 3*b_stride];
 
284
        FIX_MV_MBAFF(h->topright_type, diagonal_ref, C, 2);
 
285
    }else if(h->topright_type){
 
286
        diagonal_ref = LIST_NOT_USED;
 
287
        C = zeromv;
 
288
    }else{
 
289
        if(USES_LIST(h->topleft_type, 0)){
 
290
            diagonal_ref = ref[4*h->topleft_mb_xy + 1 + (h->topleft_partition & 2)];
 
291
            C = mv[h->mb2b_xy[h->topleft_mb_xy] + 3 + b_stride + (h->topleft_partition & 2*b_stride)];
 
292
            FIX_MV_MBAFF(h->topleft_type, diagonal_ref, C, 2);
 
293
        }else if(h->topleft_type){
 
294
            diagonal_ref = LIST_NOT_USED;
 
295
            C = zeromv;
 
296
        }else{
 
297
            diagonal_ref = PART_NOT_AVAILABLE;
 
298
            C = zeromv;
 
299
        }
 
300
    }
 
301
 
 
302
    match_count= !diagonal_ref + !top_ref + !left_ref;
 
303
    tprintf(h->s.avctx, "pred_pskip_motion match_count=%d\n", match_count);
 
304
    if(match_count > 1){
 
305
        mx = mid_pred(A[0], B[0], C[0]);
 
306
        my = mid_pred(A[1], B[1], C[1]);
 
307
    }else if(match_count==1){
 
308
        if(!left_ref){
 
309
            mx = A[0];
 
310
            my = A[1];
 
311
        }else if(!top_ref){
 
312
            mx = B[0];
 
313
            my = B[1];
 
314
        }else{
 
315
            mx = C[0];
 
316
            my = C[1];
 
317
        }
 
318
    }else{
 
319
        mx = mid_pred(A[0], B[0], C[0]);
 
320
        my = mid_pred(A[1], B[1], C[1]);
 
321
    }
 
322
 
 
323
    fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4);
 
324
    return;
 
325
zeromv:
 
326
    fill_rectangle( h->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4);
 
327
    return;
 
328
}
 
329
 
 
330
static void fill_decode_neighbors(H264Context *h, int mb_type){
 
331
    MpegEncContext * const s = &h->s;
 
332
    const int mb_xy= h->mb_xy;
 
333
    int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS];
 
334
    static const uint8_t left_block_options[4][32]={
 
335
        {0,1,2,3,7,10,8,11,3+0*4, 3+1*4, 3+2*4, 3+3*4, 1+4*4, 1+8*4, 1+5*4, 1+9*4},
 
336
        {2,2,3,3,8,11,8,11,3+2*4, 3+2*4, 3+3*4, 3+3*4, 1+5*4, 1+9*4, 1+5*4, 1+9*4},
 
337
        {0,0,1,1,7,10,7,10,3+0*4, 3+0*4, 3+1*4, 3+1*4, 1+4*4, 1+8*4, 1+4*4, 1+8*4},
 
338
        {0,2,0,2,7,10,7,10,3+0*4, 3+2*4, 3+0*4, 3+2*4, 1+4*4, 1+8*4, 1+4*4, 1+8*4}
 
339
    };
 
340
 
 
341
    h->topleft_partition= -1;
 
342
 
 
343
    top_xy     = mb_xy  - (s->mb_stride << MB_FIELD);
 
344
 
 
345
    /* Wow, what a mess, why didn't they simplify the interlacing & intra
 
346
     * stuff, I can't imagine that these complex rules are worth it. */
 
347
 
 
348
    topleft_xy = top_xy - 1;
 
349
    topright_xy= top_xy + 1;
 
350
    left_xy[LBOT] = left_xy[LTOP] = mb_xy-1;
 
351
    h->left_block = left_block_options[0];
 
352
    if(FRAME_MBAFF){
 
353
        const int left_mb_field_flag = IS_INTERLACED(s->current_picture.f.mb_type[mb_xy - 1]);
 
354
        const int curr_mb_field_flag = IS_INTERLACED(mb_type);
 
355
        if(s->mb_y&1){
 
356
            if (left_mb_field_flag != curr_mb_field_flag) {
 
357
                left_xy[LBOT] = left_xy[LTOP] = mb_xy - s->mb_stride - 1;
 
358
                if (curr_mb_field_flag) {
 
359
                    left_xy[LBOT] += s->mb_stride;
 
360
                    h->left_block = left_block_options[3];
 
361
                } else {
 
362
                    topleft_xy += s->mb_stride;
 
363
                    // take top left mv from the middle of the mb, as opposed to all other modes which use the bottom right partition
 
364
                    h->topleft_partition = 0;
 
365
                    h->left_block = left_block_options[1];
 
366
                }
 
367
            }
 
368
        }else{
 
369
            if(curr_mb_field_flag){
 
370
                topleft_xy  += s->mb_stride & (((s->current_picture.f.mb_type[top_xy - 1] >> 7) & 1) - 1);
 
371
                topright_xy += s->mb_stride & (((s->current_picture.f.mb_type[top_xy + 1] >> 7) & 1) - 1);
 
372
                top_xy      += s->mb_stride & (((s->current_picture.f.mb_type[top_xy    ] >> 7) & 1) - 1);
 
373
            }
 
374
            if (left_mb_field_flag != curr_mb_field_flag) {
 
375
                if (curr_mb_field_flag) {
 
376
                    left_xy[LBOT] += s->mb_stride;
 
377
                    h->left_block = left_block_options[3];
 
378
                } else {
 
379
                    h->left_block = left_block_options[2];
 
380
                }
 
381
            }
 
382
        }
 
383
    }
 
384
 
 
385
    h->topleft_mb_xy = topleft_xy;
 
386
    h->top_mb_xy     = top_xy;
 
387
    h->topright_mb_xy= topright_xy;
 
388
    h->left_mb_xy[LTOP] = left_xy[LTOP];
 
389
    h->left_mb_xy[LBOT] = left_xy[LBOT];
 
390
    //FIXME do we need all in the context?
 
391
 
 
392
    h->topleft_type    = s->current_picture.f.mb_type[topleft_xy];
 
393
    h->top_type        = s->current_picture.f.mb_type[top_xy];
 
394
    h->topright_type   = s->current_picture.f.mb_type[topright_xy];
 
395
    h->left_type[LTOP] = s->current_picture.f.mb_type[left_xy[LTOP]];
 
396
    h->left_type[LBOT] = s->current_picture.f.mb_type[left_xy[LBOT]];
 
397
 
 
398
    if(FMO){
 
399
    if(h->slice_table[topleft_xy    ] != h->slice_num) h->topleft_type = 0;
 
400
    if(h->slice_table[top_xy        ] != h->slice_num) h->top_type     = 0;
 
401
    if(h->slice_table[left_xy[LTOP] ] != h->slice_num) h->left_type[LTOP] = h->left_type[LBOT] = 0;
 
402
    }else{
 
403
        if(h->slice_table[topleft_xy ] != h->slice_num){
 
404
            h->topleft_type = 0;
 
405
            if(h->slice_table[top_xy        ] != h->slice_num) h->top_type     = 0;
 
406
            if(h->slice_table[left_xy[LTOP] ] != h->slice_num) h->left_type[LTOP] = h->left_type[LBOT] = 0;
 
407
        }
 
408
    }
 
409
    if(h->slice_table[topright_xy] != h->slice_num) h->topright_type= 0;
 
410
}
 
411
 
 
412
static void fill_decode_caches(H264Context *h, int mb_type){
 
413
    MpegEncContext * const s = &h->s;
 
414
    int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS];
 
415
    int topleft_type, top_type, topright_type, left_type[LEFT_MBS];
 
416
    const uint8_t * left_block= h->left_block;
 
417
    int i;
 
418
    uint8_t *nnz;
 
419
    uint8_t *nnz_cache;
 
420
 
 
421
    topleft_xy     = h->topleft_mb_xy;
 
422
    top_xy         = h->top_mb_xy;
 
423
    topright_xy    = h->topright_mb_xy;
 
424
    left_xy[LTOP]  = h->left_mb_xy[LTOP];
 
425
    left_xy[LBOT]  = h->left_mb_xy[LBOT];
 
426
    topleft_type   = h->topleft_type;
 
427
    top_type       = h->top_type;
 
428
    topright_type  = h->topright_type;
 
429
    left_type[LTOP]= h->left_type[LTOP];
 
430
    left_type[LBOT]= h->left_type[LBOT];
 
431
 
 
432
    if(!IS_SKIP(mb_type)){
 
433
        if(IS_INTRA(mb_type)){
 
434
            int type_mask= h->pps.constrained_intra_pred ? IS_INTRA(-1) : -1;
 
435
            h->topleft_samples_available=
 
436
            h->top_samples_available=
 
437
            h->left_samples_available= 0xFFFF;
 
438
            h->topright_samples_available= 0xEEEA;
 
439
 
 
440
            if(!(top_type & type_mask)){
 
441
                h->topleft_samples_available= 0xB3FF;
 
442
                h->top_samples_available= 0x33FF;
 
443
                h->topright_samples_available= 0x26EA;
 
444
            }
 
445
            if(IS_INTERLACED(mb_type) != IS_INTERLACED(left_type[LTOP])){
 
446
                if(IS_INTERLACED(mb_type)){
 
447
                    if(!(left_type[LTOP] & type_mask)){
 
448
                        h->topleft_samples_available&= 0xDFFF;
 
449
                        h->left_samples_available&= 0x5FFF;
 
450
                    }
 
451
                    if(!(left_type[LBOT] & type_mask)){
 
452
                        h->topleft_samples_available&= 0xFF5F;
 
453
                        h->left_samples_available&= 0xFF5F;
 
454
                    }
 
455
                }else{
 
456
                    int left_typei = s->current_picture.f.mb_type[left_xy[LTOP] + s->mb_stride];
 
457
 
 
458
                    assert(left_xy[LTOP] == left_xy[LBOT]);
 
459
                    if(!((left_typei & type_mask) && (left_type[LTOP] & type_mask))){
 
460
                        h->topleft_samples_available&= 0xDF5F;
 
461
                        h->left_samples_available&= 0x5F5F;
 
462
                    }
 
463
                }
 
464
            }else{
 
465
                if(!(left_type[LTOP] & type_mask)){
 
466
                    h->topleft_samples_available&= 0xDF5F;
 
467
                    h->left_samples_available&= 0x5F5F;
 
468
                }
 
469
            }
 
470
 
 
471
            if(!(topleft_type & type_mask))
 
472
                h->topleft_samples_available&= 0x7FFF;
 
473
 
 
474
            if(!(topright_type & type_mask))
 
475
                h->topright_samples_available&= 0xFBFF;
 
476
 
 
477
            if(IS_INTRA4x4(mb_type)){
 
478
                if(IS_INTRA4x4(top_type)){
 
479
                    AV_COPY32(h->intra4x4_pred_mode_cache+4+8*0, h->intra4x4_pred_mode + h->mb2br_xy[top_xy]);
 
480
                }else{
 
481
                    h->intra4x4_pred_mode_cache[4+8*0]=
 
482
                    h->intra4x4_pred_mode_cache[5+8*0]=
 
483
                    h->intra4x4_pred_mode_cache[6+8*0]=
 
484
                    h->intra4x4_pred_mode_cache[7+8*0]= 2 - 3*!(top_type & type_mask);
 
485
                }
 
486
                for(i=0; i<2; i++){
 
487
                    if(IS_INTRA4x4(left_type[LEFT(i)])){
 
488
                        int8_t *mode= h->intra4x4_pred_mode + h->mb2br_xy[left_xy[LEFT(i)]];
 
489
                        h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= mode[6-left_block[0+2*i]];
 
490
                        h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= mode[6-left_block[1+2*i]];
 
491
                    }else{
 
492
                        h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]=
 
493
                        h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= 2 - 3*!(left_type[LEFT(i)] & type_mask);
 
494
                    }
 
495
                }
 
496
            }
 
497
        }
 
498
 
 
499
 
 
500
/*
 
501
0 . T T. T T T T
 
502
1 L . .L . . . .
 
503
2 L . .L . . . .
 
504
3 . T TL . . . .
 
505
4 L . .L . . . .
 
506
5 L . .. . . . .
 
507
*/
 
508
//FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec)
 
509
    nnz_cache = h->non_zero_count_cache;
 
510
    if(top_type){
 
511
        nnz = h->non_zero_count[top_xy];
 
512
        AV_COPY32(&nnz_cache[4+8* 0], &nnz[4*3]);
 
513
        if(!s->chroma_y_shift){
 
514
            AV_COPY32(&nnz_cache[4+8* 5], &nnz[4* 7]);
 
515
            AV_COPY32(&nnz_cache[4+8*10], &nnz[4*11]);
 
516
        }else{
 
517
            AV_COPY32(&nnz_cache[4+8* 5], &nnz[4* 5]);
 
518
            AV_COPY32(&nnz_cache[4+8*10], &nnz[4* 9]);
 
519
        }
 
520
    }else{
 
521
        uint32_t top_empty = CABAC && !IS_INTRA(mb_type) ? 0 : 0x40404040;
 
522
        AV_WN32A(&nnz_cache[4+8* 0], top_empty);
 
523
        AV_WN32A(&nnz_cache[4+8* 5], top_empty);
 
524
        AV_WN32A(&nnz_cache[4+8*10], top_empty);
 
525
    }
 
526
 
 
527
    for (i=0; i<2; i++) {
 
528
        if(left_type[LEFT(i)]){
 
529
            nnz = h->non_zero_count[left_xy[LEFT(i)]];
 
530
            nnz_cache[3+8* 1 + 2*8*i]= nnz[left_block[8+0+2*i]];
 
531
            nnz_cache[3+8* 2 + 2*8*i]= nnz[left_block[8+1+2*i]];
 
532
            if(CHROMA444){
 
533
                nnz_cache[3+8* 6 + 2*8*i]= nnz[left_block[8+0+2*i]+4*4];
 
534
                nnz_cache[3+8* 7 + 2*8*i]= nnz[left_block[8+1+2*i]+4*4];
 
535
                nnz_cache[3+8*11 + 2*8*i]= nnz[left_block[8+0+2*i]+8*4];
 
536
                nnz_cache[3+8*12 + 2*8*i]= nnz[left_block[8+1+2*i]+8*4];
 
537
            }else if(CHROMA422) {
 
538
                nnz_cache[3+8* 6 + 2*8*i]= nnz[left_block[8+0+2*i]-2+4*4];
 
539
                nnz_cache[3+8* 7 + 2*8*i]= nnz[left_block[8+1+2*i]-2+4*4];
 
540
                nnz_cache[3+8*11 + 2*8*i]= nnz[left_block[8+0+2*i]-2+8*4];
 
541
                nnz_cache[3+8*12 + 2*8*i]= nnz[left_block[8+1+2*i]-2+8*4];
 
542
            }else{
 
543
                nnz_cache[3+8* 6 +   8*i]= nnz[left_block[8+4+2*i]];
 
544
                nnz_cache[3+8*11 +   8*i]= nnz[left_block[8+5+2*i]];
 
545
            }
 
546
        }else{
 
547
            nnz_cache[3+8* 1 + 2*8*i]=
 
548
            nnz_cache[3+8* 2 + 2*8*i]=
 
549
            nnz_cache[3+8* 6 + 2*8*i]=
 
550
            nnz_cache[3+8* 7 + 2*8*i]=
 
551
            nnz_cache[3+8*11 + 2*8*i]=
 
552
            nnz_cache[3+8*12 + 2*8*i]= CABAC && !IS_INTRA(mb_type) ? 0 : 64;
 
553
        }
 
554
    }
 
555
 
 
556
    if( CABAC ) {
 
557
        // top_cbp
 
558
        if(top_type) {
 
559
            h->top_cbp = h->cbp_table[top_xy];
 
560
        } else {
 
561
            h->top_cbp = IS_INTRA(mb_type) ? 0x7CF : 0x00F;
 
562
        }
 
563
        // left_cbp
 
564
        if (left_type[LTOP]) {
 
565
            h->left_cbp =   (h->cbp_table[left_xy[LTOP]] & 0x7F0)
 
566
                        |  ((h->cbp_table[left_xy[LTOP]]>>(left_block[0]&(~1)))&2)
 
567
                        | (((h->cbp_table[left_xy[LBOT]]>>(left_block[2]&(~1)))&2) << 2);
 
568
        } else {
 
569
            h->left_cbp = IS_INTRA(mb_type) ? 0x7CF : 0x00F;
 
570
        }
 
571
    }
 
572
    }
 
573
 
 
574
    if(IS_INTER(mb_type) || (IS_DIRECT(mb_type) && h->direct_spatial_mv_pred)){
 
575
        int list;
 
576
        int b_stride = h->b_stride;
 
577
        for(list=0; list<h->list_count; list++){
 
578
            int8_t *ref_cache = &h->ref_cache[list][scan8[0]];
 
579
            int8_t *ref       = s->current_picture.f.ref_index[list];
 
580
            int16_t (*mv_cache)[2] = &h->mv_cache[list][scan8[0]];
 
581
            int16_t (*mv)[2]       = s->current_picture.f.motion_val[list];
 
582
            if(!USES_LIST(mb_type, list)){
 
583
                continue;
 
584
            }
 
585
            assert(!(IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred));
 
586
 
 
587
            if(USES_LIST(top_type, list)){
 
588
                const int b_xy= h->mb2b_xy[top_xy] + 3*b_stride;
 
589
                AV_COPY128(mv_cache[0 - 1*8], mv[b_xy + 0]);
 
590
                ref_cache[0 - 1*8]=
 
591
                ref_cache[1 - 1*8]= ref[4*top_xy + 2];
 
592
                ref_cache[2 - 1*8]=
 
593
                ref_cache[3 - 1*8]= ref[4*top_xy + 3];
 
594
            }else{
 
595
                AV_ZERO128(mv_cache[0 - 1*8]);
 
596
                AV_WN32A(&ref_cache[0 - 1*8], ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101u);
 
597
            }
 
598
 
 
599
            if(mb_type & (MB_TYPE_16x8|MB_TYPE_8x8)){
 
600
            for(i=0; i<2; i++){
 
601
                int cache_idx = -1 + i*2*8;
 
602
                if(USES_LIST(left_type[LEFT(i)], list)){
 
603
                    const int b_xy= h->mb2b_xy[left_xy[LEFT(i)]] + 3;
 
604
                    const int b8_xy= 4*left_xy[LEFT(i)] + 1;
 
605
                    AV_COPY32(mv_cache[cache_idx  ], mv[b_xy + b_stride*left_block[0+i*2]]);
 
606
                    AV_COPY32(mv_cache[cache_idx+8], mv[b_xy + b_stride*left_block[1+i*2]]);
 
607
                    ref_cache[cache_idx  ]= ref[b8_xy + (left_block[0+i*2]&~1)];
 
608
                    ref_cache[cache_idx+8]= ref[b8_xy + (left_block[1+i*2]&~1)];
 
609
                }else{
 
610
                    AV_ZERO32(mv_cache[cache_idx  ]);
 
611
                    AV_ZERO32(mv_cache[cache_idx+8]);
 
612
                    ref_cache[cache_idx  ]=
 
613
                    ref_cache[cache_idx+8]= (left_type[LEFT(i)]) ? LIST_NOT_USED : PART_NOT_AVAILABLE;
 
614
                }
 
615
            }
 
616
            }else{
 
617
                if(USES_LIST(left_type[LTOP], list)){
 
618
                    const int b_xy= h->mb2b_xy[left_xy[LTOP]] + 3;
 
619
                    const int b8_xy= 4*left_xy[LTOP] + 1;
 
620
                    AV_COPY32(mv_cache[-1], mv[b_xy + b_stride*left_block[0]]);
 
621
                    ref_cache[-1]= ref[b8_xy + (left_block[0]&~1)];
 
622
                }else{
 
623
                    AV_ZERO32(mv_cache[-1]);
 
624
                    ref_cache[-1]= left_type[LTOP] ? LIST_NOT_USED : PART_NOT_AVAILABLE;
 
625
                }
 
626
            }
 
627
 
 
628
            if(USES_LIST(topright_type, list)){
 
629
                const int b_xy= h->mb2b_xy[topright_xy] + 3*b_stride;
 
630
                AV_COPY32(mv_cache[4 - 1*8], mv[b_xy]);
 
631
                ref_cache[4 - 1*8]= ref[4*topright_xy + 2];
 
632
            }else{
 
633
                AV_ZERO32(mv_cache[4 - 1*8]);
 
634
                ref_cache[4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
 
635
            }
 
636
            if(ref_cache[4 - 1*8] < 0){
 
637
                if(USES_LIST(topleft_type, list)){
 
638
                    const int b_xy = h->mb2b_xy[topleft_xy] + 3 + b_stride + (h->topleft_partition & 2*b_stride);
 
639
                    const int b8_xy= 4*topleft_xy + 1 + (h->topleft_partition & 2);
 
640
                    AV_COPY32(mv_cache[-1 - 1*8], mv[b_xy]);
 
641
                    ref_cache[-1 - 1*8]= ref[b8_xy];
 
642
                }else{
 
643
                    AV_ZERO32(mv_cache[-1 - 1*8]);
 
644
                    ref_cache[-1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
 
645
                }
 
646
            }
 
647
 
 
648
            if((mb_type&(MB_TYPE_SKIP|MB_TYPE_DIRECT2)) && !FRAME_MBAFF)
 
649
                continue;
 
650
 
 
651
            if(!(mb_type&(MB_TYPE_SKIP|MB_TYPE_DIRECT2))){
 
652
                uint8_t (*mvd_cache)[2] = &h->mvd_cache[list][scan8[0]];
 
653
                uint8_t (*mvd)[2] = h->mvd_table[list];
 
654
                ref_cache[2+8*0] =
 
655
                ref_cache[2+8*2] = PART_NOT_AVAILABLE;
 
656
                AV_ZERO32(mv_cache[2+8*0]);
 
657
                AV_ZERO32(mv_cache[2+8*2]);
 
658
 
 
659
                if( CABAC ) {
 
660
                    if(USES_LIST(top_type, list)){
 
661
                        const int b_xy= h->mb2br_xy[top_xy];
 
662
                        AV_COPY64(mvd_cache[0 - 1*8], mvd[b_xy + 0]);
 
663
                    }else{
 
664
                        AV_ZERO64(mvd_cache[0 - 1*8]);
 
665
                    }
 
666
                    if(USES_LIST(left_type[LTOP], list)){
 
667
                        const int b_xy= h->mb2br_xy[left_xy[LTOP]] + 6;
 
668
                        AV_COPY16(mvd_cache[-1 + 0*8], mvd[b_xy - left_block[0]]);
 
669
                        AV_COPY16(mvd_cache[-1 + 1*8], mvd[b_xy - left_block[1]]);
 
670
                    }else{
 
671
                        AV_ZERO16(mvd_cache[-1 + 0*8]);
 
672
                        AV_ZERO16(mvd_cache[-1 + 1*8]);
 
673
                    }
 
674
                    if(USES_LIST(left_type[LBOT], list)){
 
675
                        const int b_xy= h->mb2br_xy[left_xy[LBOT]] + 6;
 
676
                        AV_COPY16(mvd_cache[-1 + 2*8], mvd[b_xy - left_block[2]]);
 
677
                        AV_COPY16(mvd_cache[-1 + 3*8], mvd[b_xy - left_block[3]]);
 
678
                    }else{
 
679
                        AV_ZERO16(mvd_cache[-1 + 2*8]);
 
680
                        AV_ZERO16(mvd_cache[-1 + 3*8]);
 
681
                    }
 
682
                    AV_ZERO16(mvd_cache[2+8*0]);
 
683
                    AV_ZERO16(mvd_cache[2+8*2]);
 
684
                    if(h->slice_type_nos == AV_PICTURE_TYPE_B){
 
685
                        uint8_t *direct_cache = &h->direct_cache[scan8[0]];
 
686
                        uint8_t *direct_table = h->direct_table;
 
687
                        fill_rectangle(direct_cache, 4, 4, 8, MB_TYPE_16x16>>1, 1);
 
688
 
 
689
                        if(IS_DIRECT(top_type)){
 
690
                            AV_WN32A(&direct_cache[-1*8], 0x01010101u*(MB_TYPE_DIRECT2>>1));
 
691
                        }else if(IS_8X8(top_type)){
 
692
                            int b8_xy = 4*top_xy;
 
693
                            direct_cache[0 - 1*8]= direct_table[b8_xy + 2];
 
694
                            direct_cache[2 - 1*8]= direct_table[b8_xy + 3];
 
695
                        }else{
 
696
                            AV_WN32A(&direct_cache[-1*8], 0x01010101*(MB_TYPE_16x16>>1));
 
697
                        }
 
698
 
 
699
                        if(IS_DIRECT(left_type[LTOP]))
 
700
                            direct_cache[-1 + 0*8]= MB_TYPE_DIRECT2>>1;
 
701
                        else if(IS_8X8(left_type[LTOP]))
 
702
                            direct_cache[-1 + 0*8]= direct_table[4*left_xy[LTOP] + 1 + (left_block[0]&~1)];
 
703
                        else
 
704
                            direct_cache[-1 + 0*8]= MB_TYPE_16x16>>1;
 
705
 
 
706
                        if(IS_DIRECT(left_type[LBOT]))
 
707
                            direct_cache[-1 + 2*8]= MB_TYPE_DIRECT2>>1;
 
708
                        else if(IS_8X8(left_type[LBOT]))
 
709
                            direct_cache[-1 + 2*8]= direct_table[4*left_xy[LBOT] + 1 + (left_block[2]&~1)];
 
710
                        else
 
711
                            direct_cache[-1 + 2*8]= MB_TYPE_16x16>>1;
 
712
                    }
 
713
                }
 
714
            }
 
715
            if(FRAME_MBAFF){
 
716
#define MAP_MVS\
 
717
                    MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\
 
718
                    MAP_F2F(scan8[0] + 0 - 1*8, top_type)\
 
719
                    MAP_F2F(scan8[0] + 1 - 1*8, top_type)\
 
720
                    MAP_F2F(scan8[0] + 2 - 1*8, top_type)\
 
721
                    MAP_F2F(scan8[0] + 3 - 1*8, top_type)\
 
722
                    MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\
 
723
                    MAP_F2F(scan8[0] - 1 + 0*8, left_type[LTOP])\
 
724
                    MAP_F2F(scan8[0] - 1 + 1*8, left_type[LTOP])\
 
725
                    MAP_F2F(scan8[0] - 1 + 2*8, left_type[LBOT])\
 
726
                    MAP_F2F(scan8[0] - 1 + 3*8, left_type[LBOT])
 
727
                if(MB_FIELD){
 
728
#define MAP_F2F(idx, mb_type)\
 
729
                    if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\
 
730
                        h->ref_cache[list][idx] <<= 1;\
 
731
                        h->mv_cache[list][idx][1] /= 2;\
 
732
                        h->mvd_cache[list][idx][1] >>=1;\
 
733
                    }
 
734
                    MAP_MVS
 
735
#undef MAP_F2F
 
736
                }else{
 
737
#define MAP_F2F(idx, mb_type)\
 
738
                    if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\
 
739
                        h->ref_cache[list][idx] >>= 1;\
 
740
                        h->mv_cache[list][idx][1] <<= 1;\
 
741
                        h->mvd_cache[list][idx][1] <<= 1;\
 
742
                    }
 
743
                    MAP_MVS
 
744
#undef MAP_F2F
 
745
                }
 
746
            }
 
747
        }
 
748
    }
 
749
 
 
750
        h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[LTOP]);
 
751
}
 
752
 
 
753
/**
 
754
 * decodes a P_SKIP or B_SKIP macroblock
 
755
 */
 
756
static void av_unused decode_mb_skip(H264Context *h){
 
757
    MpegEncContext * const s = &h->s;
 
758
    const int mb_xy= h->mb_xy;
 
759
    int mb_type=0;
 
760
 
 
761
    memset(h->non_zero_count[mb_xy], 0, 48);
 
762
 
 
763
    if(MB_FIELD)
 
764
        mb_type|= MB_TYPE_INTERLACED;
 
765
 
 
766
    if( h->slice_type_nos == AV_PICTURE_TYPE_B )
 
767
    {
 
768
        // just for fill_caches. pred_direct_motion will set the real mb_type
 
769
        mb_type|= MB_TYPE_L0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP;
 
770
        if(h->direct_spatial_mv_pred){
 
771
            fill_decode_neighbors(h, mb_type);
 
772
        fill_decode_caches(h, mb_type); //FIXME check what is needed and what not ...
 
773
        }
 
774
        ff_h264_pred_direct_motion(h, &mb_type);
 
775
        mb_type|= MB_TYPE_SKIP;
 
776
    }
 
777
    else
 
778
    {
 
779
        mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP;
 
780
 
 
781
        fill_decode_neighbors(h, mb_type);
 
782
        pred_pskip_motion(h);
 
783
    }
 
784
 
 
785
    write_back_motion(h, mb_type);
 
786
    s->current_picture.f.mb_type[mb_xy]      = mb_type;
 
787
    s->current_picture.f.qscale_table[mb_xy] = s->qscale;
 
788
    h->slice_table[ mb_xy ]= h->slice_num;
 
789
    h->prev_mb_skipped= 1;
234
790
}
235
791
 
236
792
#endif /* AVCODEC_H264_MVPRED_H */