falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
56718 Commits
32 Branches
702MB
Tree: face578d56
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'face578d56'
${ noResults }
FFmpeg/libavcodec/mpegvideo_motion.c

910 lines
34KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2000,2001 Fabrice Bellard

  3.  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>

  4.  *

  5.  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>

  6.  *

  7.  * This file is part of FFmpeg.

  8.  *

  9.  * FFmpeg is free software; you can redistribute it and/or

  10.  * modify it under the terms of the GNU Lesser General Public

  11.  * License as published by the Free Software Foundation; either

  12.  * version 2.1 of the License, or (at your option) any later version.

  13.  *

  14.  * FFmpeg is distributed in the hope that it will be useful,

  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  17.  * Lesser General Public License for more details.

  18.  *

  19.  * You should have received a copy of the GNU Lesser General Public

  20.  * License along with FFmpeg; if not, write to the Free Software

  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  22.  */

  23. 

  24. #include <string.h>

  25. 

  26. #include "libavutil/avassert.h"

  27. #include "libavutil/internal.h"

  28. #include "avcodec.h"

  29. #include "dsputil.h"

  30. #include "h261.h"

  31. #include "mpegvideo.h"

  32. #include "mjpegenc.h"

  33. #include "msmpeg4.h"

  34. #include <limits.h>

  35. 

  36. static void gmc1_motion(MpegEncContext *s,

  37.                         uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

  38.                         uint8_t **ref_picture)

  39. {

  40.     uint8_t *ptr;

  41.     int src_x, src_y;

  42.     ptrdiff_t offset, linesize, uvlinesize;

  43.     int motion_x, motion_y;

  44.     int emu=0;

  45. 

  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);

  53.     if (src_x == s->width)

  54.         motion_x =0;

  55.     src_y = av_clip(src_y, -16, s->height);

  56.     if (src_y == s->height)

  57.         motion_y =0;

  58. 

  59.     linesize = s->linesize;

  60.     uvlinesize = s->uvlinesize;

  61. 

  62.     ptr = ref_picture[0] + (src_y * linesize) + src_x;

  63. 

  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,

  68.                                      s->h_edge_pos, s->v_edge_pos);

  69.             ptr= s->edge_emu_buffer;

  70.         }

  71. 

  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{

  76.         int dxy;

  77. 

  78.         dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);

  79.         if (s->no_rounding){

  80.             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);

  83.         }

  84.     }

  85. 

  86.     if(CONFIG_GRAY && s->flags&CODEC_FLAG_GRAY) return;

  87. 

  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;

  100. 

  101.     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;

  110.         }

  111.     s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);

  112. 

  113.     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;

  119.     }

  120.     s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);

  121. 

  122.     return;

  123. }

  124. 

  125. static void gmc_motion(MpegEncContext *s,

  126.                        uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

  127.                        uint8_t **ref_picture)

  128. {

  129.     uint8_t *ptr;

  130.     int linesize, uvlinesize;

  131.     const int a= s->sprite_warping_accuracy;

  132.     int ox, oy;

  133. 

  134.     linesize = s->linesize;

  135.     uvlinesize = s->uvlinesize;

  136. 

  137.     ptr = ref_picture[0];

  138. 

  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;

  141. 

  142.     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;

  161. 

  162.     ptr = ref_picture[1];

  163.     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);

  170. 

  171.     ptr = ref_picture[2];

  172.     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);

  179. }

  180. 

  181. 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)

  186. {

  187.     int dxy = 0;

  188.     int emu=0;

  189. 

  190.     src_x += motion_x >> 1;

  191.     src_y += motion_y >> 1;

  192. 

  193.     /* WARNING: do no forget half pels */

  194.     src_x = av_clip(src_x, -16, s->width); //FIXME unneeded for emu?

  195.     if (src_x != s->width)

  196.         dxy |= motion_x & 1;

  197.     src_y = av_clip(src_y, -16, s->height);

  198.     if (src_y != s->height)

  199.         dxy |= (motion_y & 1) << 1;

  200.     src += src_y * s->linesize + src_x;

  201. 

  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;

  210.         }

  211.     }

  212.     pix_op[dxy](dest, src, s->linesize, 8);

  213.     return emu;

  214. }

  215. 

  216. static av_always_inline

  217. 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)

  222. {

  223.     uint8_t *ptr_y, *ptr_cb, *ptr_cr;

  224.     int dxy, uvdxy, mx, my, src_x, src_y,

  225.         uvsrc_x, uvsrc_y, v_edge_pos;

  226.     ptrdiff_t uvlinesize, linesize;

  227. 

  228. #if 0

  229. if(s->quarter_sample)

  230. {

  231.     motion_x>>=1;

  232.     motion_y>>=1;

  233. }

  234. #endif

  235. 

  236.     v_edge_pos = s->v_edge_pos >> field_based;

  237.     linesize   = s->current_picture.f.linesize[0] << field_based;

  238.     uvlinesize = s->current_picture.f.linesize[1] << field_based;

  239. 

  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);

  243. 

  244.     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;

  255.         }

  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;

  262.     } 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);

  269.         } 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);

  275.                 uvsrc_y = src_y;

  276.             } else {

  277.             //Chroma444

  278.                 uvdxy = dxy;

  279.                 uvsrc_x = src_x;

  280.                 uvsrc_y = src_y;

  281.             }

  282.         }

  283.     }

  284. 

  285.     ptr_y  = ref_picture[0] + src_y * linesize + src_x;

  286.     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;

  287.     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;

  288. 

  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;

  329.     }

  330. 

  331.     pix_op[0][dxy](dest_y, ptr_y, linesize, h);

  332. 

  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);

  338.     }

  339.     if(!is_mpeg12 && (CONFIG_H261_ENCODER || CONFIG_H261_DECODER) &&

  340.          s->out_format == FMT_H261){

  341.         ff_h261_loop_filter(s);

  342.     }

  343. }

  344. /* apply one mpeg motion vector to the three components */

  345. static void mpeg_motion(MpegEncContext *s,

  346.                         uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

  347.                         int field_select, uint8_t **ref_picture,

  348.                         op_pixels_func (*pix_op)[4],

  349.                         int motion_x, int motion_y, int h, int mb_y)

  350. {

  351. #if !CONFIG_SMALL

  352.     if(s->out_format == FMT_MPEG1)

  353.         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);

  356.     else

  357. #endif

  358.         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);

  361. }

  362. 

  363. static void mpeg_motion_field(MpegEncContext *s, uint8_t *dest_y,

  364.                               uint8_t *dest_cb, uint8_t *dest_cr,

  365.                               int bottom_field, int field_select,

  366.                               uint8_t **ref_picture,

  367.                               op_pixels_func (*pix_op)[4],

  368.                               int motion_x, int motion_y, int h, int mb_y)

  369. {

  370. #if !CONFIG_SMALL

  371.     if(s->out_format == FMT_MPEG1)

  372.         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);

  375.     else

  376. #endif

  377.         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);

  380. }

  381. 

  382. //FIXME move to dsputil, avg variant, 16x16 version

  383. static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){

  384.     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];

  390. #define OBMC_FILTER(x, t, l, m, r, b)\

  391.     dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3

  392. #define OBMC_FILTER4(x, t, l, m, r, b)\

  393.     OBMC_FILTER(x         , t, l, m, r, b);\

  394.     OBMC_FILTER(x+1       , t, l, m, r, b);\

  395.     OBMC_FILTER(x  +stride, t, l, m, r, b);\

  396.     OBMC_FILTER(x+1+stride, t, l, m, r, b);

  397. 

  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);

  432. }

  433. 

  434. /* obmc for 1 8x8 luma block */

  435. static inline void obmc_motion(MpegEncContext *s,

  436.                                uint8_t *dest, uint8_t *src,

  437.                                int src_x, int src_y,

  438.                                op_pixels_func *pix_op,

  439.                                int16_t mv[5][2]/* mid top left right bottom*/)

  440. #define MID    0

  441. {

  442.     int i;

  443.     uint8_t *ptr[5];

  444. 

  445.     av_assert2(s->quarter_sample==0);

  446. 

  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,

  455.                         mv[i][0], mv[i][1]);

  456.         }

  457.     }

  458. 

  459.     put_obmc(dest, ptr, s->linesize);

  460. }

  461. 

  462. 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],

  466.                                qpel_mc_func (*qpix_op)[16],

  467.                                int motion_x, int motion_y, int h)

  468. {

  469.     uint8_t *ptr_y, *ptr_cb, *ptr_cr;

  470.     int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos;

  471.     ptrdiff_t linesize, uvlinesize;

  472. 

  473.     dxy = ((motion_y & 3) << 2) | (motion_x & 3);

  474.     src_x = s->mb_x *  16                 + (motion_x >> 2);

  475.     src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);

  476. 

  477.     v_edge_pos = s->v_edge_pos >> field_based;

  478.     linesize = s->linesize << field_based;

  479.     uvlinesize = s->uvlinesize << field_based;

  480. 

  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;

  494.     }

  495.     mx= (mx>>1)|(mx&1);

  496.     my= (my>>1)|(my&1);

  497. 

  498.     uvdxy= (mx&1) | ((my&1)<<1);

  499.     mx>>=1;

  500.     my>>=1;

  501. 

  502.     uvsrc_x = s->mb_x *  8                 + mx;

  503.     uvsrc_y = s->mb_y * (8 >> field_based) + my;

  504. 

  505.     ptr_y  = ref_picture[0] +   src_y *   linesize +   src_x;

  506.     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;

  507.     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;

  508. 

  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,

  514.                                  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;

  530.         }

  531.     }

  532. 

  533.     if(!field_based)

  534.         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;

  540.         }

  541. 

  542.         if(field_select){

  543.             ptr_y  += s->linesize;

  544.             ptr_cb += s->uvlinesize;

  545.             ptr_cr += s->uvlinesize;

  546.         }

  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);

  551.     }

  552.     if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

  553.         pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);

  554.         pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);

  555.     }

  556. }

  557. 

  558. /**

  559.  * h263 chroma 4mv motion compensation.

  560.  */

  561. static void chroma_4mv_motion(MpegEncContext *s,

  562.                               uint8_t *dest_cb, uint8_t *dest_cr,

  563.                               uint8_t **ref_picture,

  564.                               op_pixels_func *pix_op,

  565.                               int mx, int my)

  566. {

  567.     int dxy, emu=0, src_x, src_y;

  568.     ptrdiff_t offset;

  569.     uint8_t *ptr;

  570. 

  571.     /* 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);

  575. 

  576.     dxy = ((my & 1) << 1) | (mx & 1);

  577.     mx >>= 1;

  578.     my >>= 1;

  579. 

  580.     src_x = s->mb_x * 8 + mx;

  581.     src_y = s->mb_y * 8 + my;

  582.     src_x = av_clip(src_x, -8, (s->width >> 1));

  583.     if (src_x == (s->width >> 1))

  584.         dxy &= ~1;

  585.     src_y = av_clip(src_y, -8, (s->height >> 1));

  586.     if (src_y == (s->height >> 1))

  587.         dxy &= ~2;

  588. 

  589.     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;

  599.         }

  600.     }

  601.     pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);

  602. 

  603.     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;

  609.     }

  610.     pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);

  611. }

  612. 

  613. static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){

  614.     /* fetch pixels for estimated mv 4 macroblocks ahead

  615.      * optimized for 64byte cache lines */

  616.     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);

  623. }

  624. 

  625. /**

  626.  * motion compensation of a single macroblock

  627.  * @param s context

  628.  * @param dest_y luma destination pointer

  629.  * @param dest_cb chroma cb/u destination pointer

  630.  * @param dest_cr chroma cr/v destination pointer

  631.  * @param dir direction (0->forward, 1->backward)

  632.  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture

  633.  * @param pix_op halfpel motion compensation function (average or put normally)

  634.  * @param qpix_op qpel motion compensation function (average or put normally)

  635.  * the motion vectors are taken from s->mv and the MV type from s->mv_type

  636.  */

  637. 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)

  643. {

  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;

  650. 

  651.     prefetch_motion(s, ref_picture, dir);

  652. 

  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. 

  719.         return;

  720.     }

  721. 

  722.     switch(s->mv_type) {

  723.     case MV_TYPE_16X16:

  724.         if(s->mcsel){

  725.             if(s->real_sprite_warping_points==1){

  726.                 gmc1_motion(s, dest_y, dest_cb, dest_cr,

  727.                             ref_picture);

  728.             }else{

  729.                 gmc_motion(s, dest_y, dest_cb, dest_cr,

  730.                             ref_picture);

  731.             }

  732.         }else if(!is_mpeg12 && s->quarter_sample){

  733.             qpel_motion(s, dest_y, dest_cb, dest_cr,

  734.                         0, 0, 0,

  735.                         ref_picture, pix_op, qpix_op,

  736.                         s->mv[dir][0][0], s->mv[dir][0][1], 16);

  737.         } else if (!is_mpeg12 && (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) &&

  738.                    s->mspel && s->codec_id == AV_CODEC_ID_WMV2) {

  739.             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.         {

  744.             mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,

  745.                         ref_picture, pix_op,

  746.                         s->mv[dir][0][0], s->mv[dir][0][1], 16, mb_y);

  747.         }

  748.         break;

  749.     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.     }

  803.         break;

  804.     case MV_TYPE_FIELD:

  805.         if (s->picture_structure == PICT_FRAME) {

  806.             if(!is_mpeg12 && s->quarter_sample){

  807.                 for(i=0; i<2; i++){

  808.                     qpel_motion(s, dest_y, dest_cb, dest_cr,

  809.                                 1, i, s->field_select[dir][i],

  810.                                 ref_picture, pix_op, qpix_op,

  811.                                 s->mv[dir][i][0], s->mv[dir][i][1], 8);

  812.                 }

  813.             }else{

  814.                 /* top field */

  815.                 mpeg_motion_field(s, dest_y, dest_cb, dest_cr,

  816.                                   0, s->field_select[dir][0],

  817.                                   ref_picture, pix_op,

  818.                                   s->mv[dir][0][0], s->mv[dir][0][1], 8, mb_y);

  819.                 /* bottom field */

  820.                 mpeg_motion_field(s, dest_y, dest_cb, dest_cr,

  821.                                   1, s->field_select[dir][1],

  822.                                   ref_picture, pix_op,

  823.                                   s->mv[dir][1][0], s->mv[dir][1][1], 8, mb_y);

  824.             }

  825.         } 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]){

  828.                 ref_picture = s->current_picture_ptr->f.data;

  829.             }

  830. 

  831.             mpeg_motion(s, dest_y, dest_cb, dest_cr,

  832.                         s->field_select[dir][0],

  833.                         ref_picture, pix_op,

  834.                         s->mv[dir][0][0], s->mv[dir][0][1], 16, mb_y>>1);

  835.         }

  836.         break;

  837.     case MV_TYPE_16X8:

  838.         for(i=0; i<2; i++){

  839.             uint8_t ** ref2picture;

  840. 

  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{

  845.                 ref2picture = s->current_picture_ptr->f.data;

  846.             }

  847. 

  848.             mpeg_motion(s, dest_y, dest_cb, dest_cr,

  849.                         s->field_select[dir][i],

  850.                         ref2picture, pix_op,

  851.                         s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8, mb_y>>1);

  852. 

  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;

  856.         }

  857.         break;

  858.     case MV_TYPE_DMV:

  859.         if(s->picture_structure == PICT_FRAME){

  860.             for(i=0; i<2; i++){

  861.                 int j;

  862.                 for(j=0; j<2; j++){

  863.                     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.                 }

  868.                 pix_op = s->hdsp.avg_pixels_tab;

  869.             }

  870.         }else{

  871.             if (!ref_picture[0]) {

  872.                 ref_picture = s->current_picture_ptr->f.data;

  873.             }

  874.             for(i=0; i<2; i++){

  875.                 mpeg_motion(s, dest_y, dest_cb, dest_cr,

  876.                             s->picture_structure != i+1,

  877.                             ref_picture, pix_op,

  878.                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],16, mb_y>>1);

  879. 

  880.                 // after put we make avg of the same block

  881.                 pix_op=s->hdsp.avg_pixels_tab;

  882. 

  883.                 //opposite parity is always in the same frame if this is second field

  884.                 if(!s->first_field){

  885.                     ref_picture = s->current_picture_ptr->f.data;

  886.                 }

  887.             }

  888.         }

  889.     break;

  890.     default: av_assert2(0);

  891.     }

  892. }

  893. 

  894. void ff_MPV_motion(MpegEncContext *s,

  895.                    uint8_t *dest_y, uint8_t *dest_cb,

  896.                    uint8_t *dest_cr, int dir,

  897.                    uint8_t **ref_picture,

  898.                    op_pixels_func (*pix_op)[4],

  899.                    qpel_mc_func (*qpix_op)[16])

  900. {

  901. #if !CONFIG_SMALL

  902.     if(s->out_format == FMT_MPEG1)

  903.         MPV_motion_internal(s, dest_y, dest_cb, dest_cr, dir,

  904.                             ref_picture, pix_op, qpix_op, 1);

  905.     else

  906. #endif

  907.         MPV_motion_internal(s, dest_y, dest_cb, dest_cr, dir,

  908.                             ref_picture, pix_op, qpix_op, 0);

  909. }