FFmpeg: libavfilter/vf_mcdeint.c Source File

FFmpeg

[フレーム]

libavfilter

vf_mcdeint.c

Go to the documentation of this file.

1 /*

3 *

4 * FFmpeg is free software; you can redistribute it and/or modify

5 * it under the terms of the GNU General Public License as published by

6 * the Free Software Foundation; either version 2 of the License, or

7 * (at your option) any later version.

8 *

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

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

11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

12 * GNU General Public License for more details.

13 *

14 * You should have received a copy of the GNU General Public License along

15 * with FFmpeg; if not, write to the Free Software Foundation, Inc.,

16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

17 */

19 /**

20 * @file

21 * Motion Compensation Deinterlacer

22 * Ported from MPlayer libmpcodecs/vf_mcdeint.c.

23 *

24 * Known Issues:

25 *

26 * The motion estimation is somewhat at the mercy of the input, if the

27 * input frames are created purely based on spatial interpolation then

28 * for example a thin black line or another random and not

29 * interpolateable pattern will cause problems.

30 * Note: completely ignoring the "unavailable" lines during motion

31 * estimation did not look any better, so the most obvious solution

32 * would be to improve tfields or penalize problematic motion vectors.

33 *

34 * If non iterative ME is used then snow currently ignores the OBMC

35 * window and as a result sometimes creates artifacts.

36 *

37 * Only past frames are used, we should ideally use future frames too,

38 * something like filtering the whole movie in forward and then

39 * backward direction seems like a interesting idea but the current

40 * filter framework is FAR from supporting such things.

41 *

42 * Combining the motion compensated image with the input image also is

43 * not as trivial as it seems, simple blindly taking even lines from

44 * one and odd ones from the other does not work at all as ME/MC

45 * sometimes has nothing in the previous frames which matches the

46 * current. The current algorithm has been found by trial and error

47 * and almost certainly can be improved...

48 */

50 #include "libavutil/opt.h"

51 #include "libavutil/pixdesc.h"

52 #include "libavcodec/avcodec.h"

53 #include "avfilter.h"

54 #include "formats.h"

55 #include "internal.h"

57 enum MCDeintMode {

58 MODE_FAST = 0,

59 MODE_MEDIUM,

60 MODE_SLOW,

61 MODE_EXTRA_SLOW,

62 MODE_NB,

63 };

65 enum MCDeintParity {

66 PARITY_TFF = 0, ///< top field first

67 PARITY_BFF = 1, ///< bottom field first

68 };

70 typedef struct {

71 const AVClass *class;

72 enum MCDeintMode mode;

73 enum MCDeintParity parity;

74 int qp;

75 AVCodecContext *enc_ctx;

76 } MCDeintContext;

78 #define OFFSET(x) offsetof(MCDeintContext, x)

79 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

80 #define CONST(name, help, val, unit) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, unit }

82 static const AVOption mcdeint_options[] = {

83 { "mode", "set mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=MODE_FAST}, 0, MODE_NB-1, FLAGS, .unit="mode" },

84 CONST("fast", NULL, MODE_FAST, "mode"),

85 CONST("medium", NULL, MODE_MEDIUM, "mode"),

86 CONST("slow", NULL, MODE_SLOW, "mode"),

87 CONST("extra_slow", NULL, MODE_EXTRA_SLOW, "mode"),

89 { "parity", "set the assumed picture field parity", OFFSET(parity), AV_OPT_TYPE_INT, {.i64=PARITY_BFF}, -1, 1, FLAGS, "parity" },

90 CONST("tff", "assume top field first", PARITY_TFF, "parity"),

91 CONST("bff", "assume bottom field first", PARITY_BFF, "parity"),

93 { "qp", "set qp", OFFSET(qp), AV_OPT_TYPE_INT, {.i64=1}, INT_MIN, INT_MAX, FLAGS },

94 { NULL }

95 };

97 AVFILTER_DEFINE_CLASS(mcdeint);

99 static int config_props(AVFilterLink *inlink)

100 {

101 AVFilterContext *ctx = inlink->dst;

102 MCDeintContext *mcdeint = ctx->priv;

103 AVCodec *enc;

104 AVCodecContext *enc_ctx;

105 AVDictionary *opts = NULL;

106 int ret;

107

108 if (!(enc = avcodec_find_encoder(AV_CODEC_ID_SNOW))) {

109 av_log(ctx, AV_LOG_ERROR, "Snow encoder is not enabled in libavcodec\n");

110 return AVERROR(EINVAL);

111 }

112

113 mcdeint->enc_ctx = avcodec_alloc_context3(enc);

114 if (!mcdeint->enc_ctx)

115 return AVERROR(ENOMEM);

116 enc_ctx = mcdeint->enc_ctx;

117 enc_ctx->width = inlink->w;

118 enc_ctx->height = inlink->h;

119 enc_ctx->time_base = (AVRational){1,25}; // meaningless

120 enc_ctx->gop_size = INT_MAX;

121 enc_ctx->max_b_frames = 0;

122 enc_ctx->pix_fmt = AV_PIX_FMT_YUV420P;

123 enc_ctx->flags = CODEC_FLAG_QSCALE | CODEC_FLAG_LOW_DELAY;

124 enc_ctx->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;

125 enc_ctx->global_quality = 1;

126 enc_ctx->me_cmp = enc_ctx->me_sub_cmp = FF_CMP_SAD;

127 enc_ctx->mb_cmp = FF_CMP_SSE;

128 av_dict_set(&opts, "memc_only", "1", 0);

129 av_dict_set(&opts, "no_bitstream", "1", 0);

130

131 switch (mcdeint->mode) {

132 case MODE_EXTRA_SLOW:

133 enc_ctx->refs = 3;

134 case MODE_SLOW:

135 enc_ctx->me_method = ME_ITER;

136 case MODE_MEDIUM:

137 enc_ctx->flags |= CODEC_FLAG_4MV;

138 enc_ctx->dia_size = 2;

139 case MODE_FAST:

140 enc_ctx->flags |= CODEC_FLAG_QPEL;

141 }

142

143 ret = avcodec_open2(enc_ctx, enc, &opts);

144 av_dict_free(&opts);

145 if (ret < 0)

146 return ret;

147

148 return 0;

149 }

150

151 static av_cold void uninit(AVFilterContext *ctx)

152 {

153 MCDeintContext *mcdeint = ctx->priv;

154

155 if (mcdeint->enc_ctx) {

156 avcodec_close(mcdeint->enc_ctx);

157 av_freep(&mcdeint->enc_ctx);

158 }

159 }

160

161 static int query_formats(AVFilterContext *ctx)

162 {

163 static const enum PixelFormat pix_fmts[] = {

164 AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE

165 };

166

167 ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));

168

169 return 0;

170 }

171

172 static int filter_frame(AVFilterLink *inlink, AVFrame *inpic)

173 {

174 MCDeintContext *mcdeint = inlink->dst->priv;

175 AVFilterLink *outlink = inlink->dst->outputs[0];

176 AVFrame *outpic, *frame_dec;

177 AVPacket pkt = {0};

178 int x, y, i, ret, got_frame = 0;

179

180 outpic = ff_get_video_buffer(outlink, outlink->w, outlink->h);

181 if (!outpic) {

182 av_frame_free(&inpic);

183 return AVERROR(ENOMEM);

184 }

185 av_frame_copy_props(outpic, inpic);

186 inpic->quality = mcdeint->qp * FF_QP2LAMBDA;

187

188 av_init_packet(&pkt);

189

190 ret = avcodec_encode_video2(mcdeint->enc_ctx, &pkt, inpic, &got_frame);

191 if (ret < 0)

192 goto end;

193

194 frame_dec = mcdeint->enc_ctx->coded_frame;

195

196 for (i = 0; i < 3; i++) {

197 int is_chroma = !!i;

198 int w = FF_CEIL_RSHIFT(inlink->w, is_chroma);

199 int h = FF_CEIL_RSHIFT(inlink->h, is_chroma);

200 int fils = frame_dec->linesize[i];

201 int srcs = inpic ->linesize[i];

202 int dsts = outpic ->linesize[i];

203

204 for (y = 0; y < h; y++) {

205 if ((y ^ mcdeint->parity) & 1) {

206 for (x = 0; x < w; x++) {

207 uint8_t *filp = &frame_dec->data[i][x + y*fils];

208 uint8_t *srcp = &inpic ->data[i][x + y*srcs];

209 uint8_t *dstp = &outpic ->data[i][x + y*dsts];

210

211 if (y > 0 && y < h-1){

212 int is_edge = x < 3 || x > w-4;

213 int diff0 = filp[-fils] - srcp[-srcs];

214 int diff1 = filp[+fils] - srcp[+srcs];

215 int temp = filp[0];

216

217 #define DELTA(j) av_clip(j, -x, w-1-x)

218

219 #define GET_SCORE_EDGE(j)\

220 FFABS(srcp[-srcs+DELTA(-1+(j))] - srcp[+srcs+DELTA(-1-(j))])+\

221 FFABS(srcp[-srcs+DELTA(j) ] - srcp[+srcs+DELTA( -(j))])+\

222 FFABS(srcp[-srcs+DELTA(1+(j)) ] - srcp[+srcs+DELTA( 1-(j))])

223

224 #define GET_SCORE(j)\

225 FFABS(srcp[-srcs-1+(j)] - srcp[+srcs-1-(j)])+\

226 FFABS(srcp[-srcs +(j)] - srcp[+srcs -(j)])+\

227 FFABS(srcp[-srcs+1+(j)] - srcp[+srcs+1-(j)])

228

229 #define CHECK_EDGE(j)\

230 { int score = GET_SCORE_EDGE(j);\

231 if (score < spatial_score){\

232 spatial_score = score;\

233 diff0 = filp[-fils+DELTA(j)] - srcp[-srcs+DELTA(j)];\

234 diff1 = filp[+fils+DELTA(-(j))] - srcp[+srcs+DELTA(-(j))];\

235

236 #define CHECK(j)\

237 { int score = GET_SCORE(j);\

238 if (score < spatial_score){\

239 spatial_score= score;\

240 diff0 = filp[-fils+(j)] - srcp[-srcs+(j)];\

241 diff1 = filp[+fils-(j)] - srcp[+srcs-(j)];\

242

243 if (is_edge) {

244 int spatial_score = GET_SCORE_EDGE(0) - 1;

245 CHECK_EDGE(-1) CHECK_EDGE(-2) }} }}

246 CHECK_EDGE( 1) CHECK_EDGE( 2) }} }}

247 } else {

248 int spatial_score = GET_SCORE(0) - 1;

249 CHECK(-1) CHECK(-2) }} }}

250 CHECK( 1) CHECK( 2) }} }}

251 }

252

253

254 if (diff0 + diff1 > 0)

255 temp -= (diff0 + diff1 - FFABS(FFABS(diff0) - FFABS(diff1)) / 2) / 2;

256 else

257 temp -= (diff0 + diff1 + FFABS(FFABS(diff0) - FFABS(diff1)) / 2) / 2;

258 *filp = *dstp = temp > 255U ? ~(temp>>31) : temp;

259 } else {

260 *dstp = *filp;

261 }

262 }

263 }

264 }

265

266 for (y = 0; y < h; y++) {

267 if (!((y ^ mcdeint->parity) & 1)) {

268 for (x = 0; x < w; x++) {

269 frame_dec->data[i][x + y*fils] =

270 outpic ->data[i][x + y*dsts] = inpic->data[i][x + y*srcs];

271 }

272 }

273 }

274 }

275 mcdeint->parity ^= 1;

276

277 end:

278 av_free_packet(&pkt);

279 av_frame_free(&inpic);

280 if (ret < 0) {

281 av_frame_free(&outpic);

282 return ret;

283 }

284 return ff_filter_frame(outlink, outpic);

285 }

286

287 static const AVFilterPad mcdeint_inputs[] = {

288 {

289 .name = "default",

290 .type = AVMEDIA_TYPE_VIDEO,

291 .filter_frame = filter_frame,

292 .config_props = config_props,

293 },

294 { NULL }

295 };

296

297 static const AVFilterPad mcdeint_outputs[] = {

298 {

299 .name = "default",

300 .type = AVMEDIA_TYPE_VIDEO,

301 },

302 { NULL }

303 };

304

305 AVFilter ff_vf_mcdeint = {

306 .name = "mcdeint",

307 .description = NULL_IF_CONFIG_SMALL("Apply motion compensating deinterlacing."),

308 .priv_size = sizeof(MCDeintContext),

309 .uninit = uninit,

310 .query_formats = query_formats,

311 .inputs = mcdeint_inputs,

312 .outputs = mcdeint_outputs,

313 .priv_class = &mcdeint_class,

314 };

Generated on Sun Mar 8 2015 02:35:07 for FFmpeg by doxygen 1.8.2