libmpcodecs/vf_mcdeint.c

   1 /*
   2  * Copyright (C) 2006 Michael Niedermayer <michaelni@gmx.at>
   3  *
   4  * This file is part of MPlayer.
   5  *
   6  * MPlayer is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * MPlayer is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21
  22 /*
  23 Known Issues:
  24 * The motion estimation is somewhat at the mercy of the input, if the input
  25   frames are created purely based on spatial interpolation then for example
  26   a thin black line or another random and not interpolateable pattern
  27   will cause problems
  28   Note: completly ignoring the "unavailable" lines during motion estimation
  29   didnt look any better, so the most obvious solution would be to improve
  30   tfields or penalize problematic motion vectors ...
  31
  32 * If non iterative ME is used then snow currently ignores the OBMC window
  33   and as a result sometimes creates artifacts
  34
  35 * only past frames are used, we should ideally use future frames too, something
  36   like filtering the whole movie in forward and then backward direction seems
  37   like a interresting idea but the current filter framework is FAR from
  38   supporting such things
  39
  40 * combining the motion compensated image with the input image also isnt
  41   as trivial as it seems, simple blindly taking even lines from one and
  42   odd ones from the other doesnt work at all as ME/MC sometimes simple
  43   has nothing in the previous frames which matches the current, the current
  44   algo has been found by trial and error and almost certainly can be
  45   improved ...
  46 */
  47
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <string.h>
  51 #include <inttypes.h>
  52 #include <math.h>
  53
  54 #include "mp_msg.h"
  55 #include "cpudetect.h"
  56
  57 #include "libavutil/intreadwrite.h"
  58 #include "libavcodec/avcodec.h"
  59 #include "libavcodec/dsputil.h"
  60
  61 #include "img_format.h"
  62 #include "mp_image.h"
  63 #include "vf.h"
  64
  65 #define MIN(a,b) ((a) > (b) ? (b) : (a))
  66 #define MAX(a,b) ((a) < (b) ? (b) : (a))
  67 #define ABS(a) ((a) > 0 ? (a) : (-(a)))
  68
  69 //===========================================================================//
  70
  71 struct vf_priv_s {
  72     int mode;
  73     int qp;
  74     int parity;
  75 #if 0
  76     int temp_stride[3];
  77     uint8_t *src[3];
  78     int16_t *temp[3];
  79 #endif
  80     int outbuf_size;
  81     uint8_t *outbuf;
  82     AVCodecContext *avctx_enc;
  83     AVFrame *frame;
  84     AVFrame *frame_dec;
  85 };
  86
  87 static void filter(struct vf_priv_s *p, uint8_t *dst[3], uint8_t *src[3], int dst_stride[3], int src_stride[3], int width, int height){
  88     int x, y, i;
  89     int out_size;
  90
  91     for(i=0; i<3; i++){
  92         p->frame->data[i]= src[i];
  93         p->frame->linesize[i]= src_stride[i];
  94     }
  95
  96     p->avctx_enc->me_cmp=
  97     p->avctx_enc->me_sub_cmp= FF_CMP_SAD /*| (p->parity ? FF_CMP_ODD : FF_CMP_EVEN)*/;
  98     p->frame->quality= p->qp*FF_QP2LAMBDA;
  99     out_size = avcodec_encode_video(p->avctx_enc, p->outbuf, p->outbuf_size, p->frame);
 100     p->frame_dec = p->avctx_enc->coded_frame;
 101
 102     for(i=0; i<3; i++){
 103         int is_chroma= !!i;
 104         int w= width >>is_chroma;
 105         int h= height>>is_chroma;
 106         int fils= p->frame_dec->linesize[i];
 107         int srcs= src_stride[i];
 108
 109         for(y=0; y<h; y++){
 110             if((y ^ p->parity) & 1){
 111                 for(x=0; x<w; x++){
 112                     if((x-2)+(y-1)*w>=0 && (x+2)+(y+1)*w<w*h){ //FIXME either alloc larger images or optimize this
 113                         uint8_t *filp= &p->frame_dec->data[i][x + y*fils];
 114                         uint8_t *srcp= &src[i][x + y*srcs];
 115                         int diff0= filp[-fils] - srcp[-srcs];
 116                         int diff1= filp[+fils] - srcp[+srcs];
 117                         int spatial_score= ABS(srcp[-srcs-1] - srcp[+srcs-1])
 118                                           +ABS(srcp[-srcs  ] - srcp[+srcs  ])
 119                                           +ABS(srcp[-srcs+1] - srcp[+srcs+1]) - 1;
 120                         int temp= filp[0];
 121
 122 #define CHECK(j)\
 123     {   int score= ABS(srcp[-srcs-1+j] - srcp[+srcs-1-j])\
 124                  + ABS(srcp[-srcs  +j] - srcp[+srcs  -j])\
 125                  + ABS(srcp[-srcs+1+j] - srcp[+srcs+1-j]);\
 126         if(score < spatial_score){\
 127             spatial_score= score;\
 128             diff0= filp[-fils+j] - srcp[-srcs+j];\
 129             diff1= filp[+fils-j] - srcp[+srcs-j];
 130
 131                         CHECK(-1) CHECK(-2) }} }}
 132                         CHECK( 1) CHECK( 2) }} }}
 133 #if 0
 134                         if((diff0 ^ diff1) > 0){
 135                             int mindiff= ABS(diff0) > ABS(diff1) ? diff1 : diff0;
 136                             temp-= mindiff;
 137                         }
 138 #elif 1
 139                         if(diff0 + diff1 > 0)
 140                             temp-= (diff0 + diff1 - ABS( ABS(diff0) - ABS(diff1) )/2)/2;
 141                         else
 142                             temp-= (diff0 + diff1 + ABS( ABS(diff0) - ABS(diff1) )/2)/2;
 143 #else
 144                         temp-= (diff0 + diff1)/2;
 145 #endif
 146 #if 1
 147                         filp[0]=
 148                         dst[i][x + y*dst_stride[i]]= temp > 255U ? ~(temp>>31) : temp;
 149 #else
 150                         dst[i][x + y*dst_stride[i]]= filp[0];
 151                         filp[0]= temp > 255U ? ~(temp>>31) : temp;
 152 #endif
 153                     }else
 154                         dst[i][x + y*dst_stride[i]]= p->frame_dec->data[i][x + y*fils];
 155                 }
 156             }
 157         }
 158         for(y=0; y<h; y++){
 159             if(!((y ^ p->parity) & 1)){
 160                 for(x=0; x<w; x++){
 161 #if 1
 162                     p->frame_dec->data[i][x + y*fils]=
 163                     dst[i][x + y*dst_stride[i]]= src[i][x + y*srcs];
 164 #else
 165                     dst[i][x + y*dst_stride[i]]= p->frame_dec->data[i][x + y*fils];
 166                     p->frame_dec->data[i][x + y*fils]= src[i][x + y*srcs];
 167 #endif
 168                 }
 169             }
 170         }
 171     }
 172     p->parity ^= 1;
 173
 174 }
 175
 176 static int config(struct vf_instance* vf,
 177         int width, int height, int d_width, int d_height,
 178         unsigned int flags, unsigned int outfmt){
 179         int i;
 180         AVCodec *enc= avcodec_find_encoder(CODEC_ID_SNOW);
 181
 182         for(i=0; i<3; i++){
 183             AVCodecContext *avctx_enc;
 184 #if 0
 185             int is_chroma= !!i;
 186             int w= ((width  + 31) & (~31))>>is_chroma;
 187             int h= ((height + 31) & (~31))>>is_chroma;
 188
 189             vf->priv->temp_stride[i]= w;
 190             vf->priv->temp[i]= malloc(vf->priv->temp_stride[i]*h*sizeof(int16_t));
 191             vf->priv->src [i]= malloc(vf->priv->temp_stride[i]*h*sizeof(uint8_t));
 192 #endif
 193             avctx_enc=
 194             vf->priv->avctx_enc= avcodec_alloc_context();
 195             avctx_enc->width = width;
 196             avctx_enc->height = height;
 197             avctx_enc->time_base= (AVRational){1,25};  // meaningless
 198             avctx_enc->gop_size = 300;
 199             avctx_enc->max_b_frames= 0;
 200             avctx_enc->pix_fmt = PIX_FMT_YUV420P;
 201             avctx_enc->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_LOW_DELAY;
 202             avctx_enc->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
 203             avctx_enc->global_quality= 1;
 204             avctx_enc->flags2= CODEC_FLAG2_MEMC_ONLY;
 205             avctx_enc->me_cmp=
 206             avctx_enc->me_sub_cmp= FF_CMP_SAD; //SSE;
 207             avctx_enc->mb_cmp= FF_CMP_SSE;
 208
 209             switch(vf->priv->mode){
 210             case 3:
 211                 avctx_enc->refs= 3;
 212             case 2:
 213                 avctx_enc->me_method= ME_ITER;
 214             case 1:
 215                 avctx_enc->flags |= CODEC_FLAG_4MV;
 216                 avctx_enc->dia_size=2;
 217 //                avctx_enc->mb_decision = MB_DECISION_RD;
 218             case 0:
 219                 avctx_enc->flags |= CODEC_FLAG_QPEL;
 220             }
 221
 222             avcodec_open(avctx_enc, enc);
 223
 224         }
 225         vf->priv->frame= avcodec_alloc_frame();
 226
 227         vf->priv->outbuf_size= width*height*10;
 228         vf->priv->outbuf= malloc(vf->priv->outbuf_size);
 229
 230         return vf_next_config(vf,width,height,d_width,d_height,flags,outfmt);
 231 }
 232
 233 static void get_image(struct vf_instance* vf, mp_image_t *mpi){
 234     if(mpi->flags&MP_IMGFLAG_PRESERVE) return; // don't change
 235 return; //caused problems, dunno why
 236     // ok, we can do pp in-place (or pp disabled):
 237     vf->dmpi=vf_get_image(vf->next,mpi->imgfmt,
 238         mpi->type, mpi->flags | MP_IMGFLAG_READABLE, mpi->width, mpi->height);
 239     mpi->planes[0]=vf->dmpi->planes[0];
 240     mpi->stride[0]=vf->dmpi->stride[0];
 241     mpi->width=vf->dmpi->width;
 242     if(mpi->flags&MP_IMGFLAG_PLANAR){
 243         mpi->planes[1]=vf->dmpi->planes[1];
 244         mpi->planes[2]=vf->dmpi->planes[2];
 245         mpi->stride[1]=vf->dmpi->stride[1];
 246         mpi->stride[2]=vf->dmpi->stride[2];
 247     }
 248     mpi->flags|=MP_IMGFLAG_DIRECT;
 249 }
 250
 251 static int put_image(struct vf_instance* vf, mp_image_t *mpi, double pts){
 252     mp_image_t *dmpi;
 253
 254     if(!(mpi->flags&MP_IMGFLAG_DIRECT)){
 255         // no DR, so get a new image! hope we'll get DR buffer:
 256         dmpi=vf_get_image(vf->next,mpi->imgfmt,
 257             MP_IMGTYPE_TEMP,
 258             MP_IMGFLAG_ACCEPT_STRIDE|MP_IMGFLAG_PREFER_ALIGNED_STRIDE,
 259             mpi->width,mpi->height);
 260         vf_clone_mpi_attributes(dmpi, mpi);
 261     }else{
 262         dmpi=vf->dmpi;
 263     }
 264
 265     filter(vf->priv, dmpi->planes, mpi->planes, dmpi->stride, mpi->stride, mpi->w, mpi->h);
 266
 267     return vf_next_put_image(vf,dmpi, pts);
 268 }
 269
 270 static void uninit(struct vf_instance* vf){
 271     if(!vf->priv) return;
 272
 273 #if 0
 274     for(i=0; i<3; i++){
 275         if(vf->priv->temp[i]) free(vf->priv->temp[i]);
 276         vf->priv->temp[i]= NULL;
 277         if(vf->priv->src[i]) free(vf->priv->src[i]);
 278         vf->priv->src[i]= NULL;
 279     }
 280 #endif
 281     if (vf->priv->avctx_enc) {
 282     avcodec_close(vf->priv->avctx_enc);
 283     av_freep(&vf->priv->avctx_enc);
 284     }
 285
 286     free(vf->priv->outbuf);
 287     free(vf->priv);
 288     vf->priv=NULL;
 289 }
 290
 291 //===========================================================================//
 292 static int query_format(struct vf_instance* vf, unsigned int fmt){
 293     switch(fmt){
 294         case IMGFMT_YV12:
 295         case IMGFMT_I420:
 296         case IMGFMT_IYUV:
 297         case IMGFMT_Y800:
 298         case IMGFMT_Y8:
 299             return vf_next_query_format(vf,fmt);
 300     }
 301     return 0;
 302 }
 303
 304 static int vf_open(vf_instance_t *vf, char *args){
 305
 306     vf->config=config;
 307     vf->put_image=put_image;
 308     vf->get_image=get_image;
 309     vf->query_format=query_format;
 310     vf->uninit=uninit;
 311     vf->priv=malloc(sizeof(struct vf_priv_s));
 312     memset(vf->priv, 0, sizeof(struct vf_priv_s));
 313
 314     avcodec_init();
 315     avcodec_register_all();
 316
 317     vf->priv->mode=0;
 318     vf->priv->parity= -1;
 319     vf->priv->qp=1;
 320
 321     if (args) sscanf(args, "%d:%d:%d", &vf->priv->mode, &vf->priv->parity, &vf->priv->qp);
 322
 323     return 1;
 324 }
 325
 326 const vf_info_t vf_info_mcdeint = {
 327     "motion compensating deinterlacer",
 328     "mcdeint",
 329     "Michael Niedermayer",
 330     "",
 331     vf_open,
 332     NULL
 333 };