FFmpeg: libavfilter/vf_pp7.c Source File

FFmpeg

[フレーム]

libavfilter

vf_pp7.c

Go to the documentation of this file.

1 /*

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

10 * (at your option) any later version.

11 *

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

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

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

15 * GNU General Public License for more details.

16 *

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

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

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

20 */

22 /**

23 * @file

24 * Postprocessing filter - 7

25 *

26 * Originally written by Michael Niedermayer for the MPlayer

27 * project, and ported by Arwa Arif for FFmpeg.

28 */

30 #include "libavutil/emms.h"

31 #include "libavutil/imgutils.h"

32 #include "libavutil/mem_internal.h"

33 #include "libavutil/opt.h"

34 #include "libavutil/pixdesc.h"

35 #include "internal.h"

36 #include "qp_table.h"

37 #include "vf_pp7.h"

38 #include "video.h"

40 enum mode {

41 MODE_HARD,

42 MODE_SOFT,

43 MODE_MEDIUM

44 };

46 #define OFFSET(x) offsetof(PP7Context, x)

47 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM

48 static const AVOption pp7_options[] = {

49 { "qp", "force a constant quantizer parameter", OFFSET(qp), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 64, FLAGS },

50 { "mode", "set thresholding mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64 = MODE_MEDIUM}, 0, 2, FLAGS, .unit = "mode" },

51 { "hard", "hard thresholding", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_HARD}, INT_MIN, INT_MAX, FLAGS, .unit = "mode" },

52 { "soft", "soft thresholding", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_SOFT}, INT_MIN, INT_MAX, FLAGS, .unit = "mode" },

53 { "medium", "medium thresholding", 0, AV_OPT_TYPE_CONST, {.i64 = MODE_MEDIUM}, INT_MIN, INT_MAX, FLAGS, .unit = "mode" },

54 { NULL }

55 };

57 AVFILTER_DEFINE_CLASS(pp7);

59 DECLARE_ALIGNED(8, static const uint8_t, dither)[8][8] = {

60 { 0, 48, 12, 60, 3, 51, 15, 63, },

61 { 32, 16, 44, 28, 35, 19, 47, 31, },

62 { 8, 56, 4, 52, 11, 59, 7, 55, },

63 { 40, 24, 36, 20, 43, 27, 39, 23, },

64 { 2, 50, 14, 62, 1, 49, 13, 61, },

65 { 34, 18, 46, 30, 33, 17, 45, 29, },

66 { 10, 58, 6, 54, 9, 57, 5, 53, },

67 { 42, 26, 38, 22, 41, 25, 37, 21, },

68 };

70 #define N0 4

71 #define N1 5

72 #define N2 10

73 #define SN0 2

74 #define SN1 2.2360679775

75 #define SN2 3.16227766017

76 #define N (1 << 16)

78 static const int factor[16] = {

79 N / (N0 * N0), N / (N0 * N1), N / (N0 * N0), N / (N0 * N2),

80 N / (N1 * N0), N / (N1 * N1), N / (N1 * N0), N / (N1 * N2),

81 N / (N0 * N0), N / (N0 * N1), N / (N0 * N0), N / (N0 * N2),

82 N / (N2 * N0), N / (N2 * N1), N / (N2 * N0), N / (N2 * N2),

83 };

85 static void init_thres2(PP7Context *p)

86 {

87 int qp, i;

88 int bias = 0; //FIXME

90 for (qp = 0; qp < 99; qp++) {

91 for (i = 0; i < 16; i++) {

92 p->thres2[qp][i] = ((i&1) ? SN2 : SN0) * ((i&4) ? SN2 : SN0) * FFMAX(1, qp) * (1<<2) - 1 - bias;

93 }

94 }

95 }

97 static inline void dctA_c(int16_t *dst, uint8_t *src, int stride)

98 {

99 int i;

100

101 for (i = 0; i < 4; i++) {

102 int s0 = src[0 * stride] + src[6 * stride];

103 int s1 = src[1 * stride] + src[5 * stride];

104 int s2 = src[2 * stride] + src[4 * stride];

105 int s3 = src[3 * stride];

106 int s = s3 + s3;

107 s3 = s - s0;

108 s0 = s + s0;

109 s = s2 + s1;

110 s2 = s2 - s1;

111 dst[0] = s0 + s;

112 dst[2] = s0 - s;

113 dst[1] = 2 * s3 + s2;

114 dst[3] = s3 - 2 * s2;

115 src++;

116 dst += 4;

117 }

118 }

119

120 static void dctB_c(int16_t *dst, int16_t *src)

121 {

122 int i;

123

124 for (i = 0; i < 4; i++) {

125 int s0 = src[0 * 4] + src[6 * 4];

126 int s1 = src[1 * 4] + src[5 * 4];

127 int s2 = src[2 * 4] + src[4 * 4];

128 int s3 = src[3 * 4];

129 int s = s3 + s3;

130 s3 = s - s0;

131 s0 = s + s0;

132 s = s2 + s1;

133 s2 = s2 - s1;

134 dst[0 * 4] = s0 + s;

135 dst[2 * 4] = s0 - s;

136 dst[1 * 4] = 2 * s3 + s2;

137 dst[3 * 4] = s3 - 2 * s2;

138 src++;

139 dst++;

140 }

141 }

142

143 static int hardthresh_c(PP7Context *p, int16_t *src, int qp)

144 {

145 int i;

146 int a;

147

148 a = src[0] * factor[0];

149 for (i = 1; i < 16; i++) {

150 unsigned int threshold1 = p->thres2[qp][i];

151 unsigned int threshold2 = threshold1 << 1;

152 int level = src[i];

153 if (((unsigned)(level + threshold1)) > threshold2)

154 a += level * factor[i];

155 }

156 return (a + (1 << 11)) >> 12;

157 }

158

159 static int mediumthresh_c(PP7Context *p, int16_t *src, int qp)

160 {

161 int i;

162 int a;

163

164 a = src[0] * factor[0];

165 for (i = 1; i < 16; i++) {

166 unsigned int threshold1 = p->thres2[qp][i];

167 unsigned int threshold2 = threshold1 << 1;

168 int level = src[i];

169 if (((unsigned)(level + threshold1)) > threshold2) {

170 if (((unsigned)(level + 2 * threshold1)) > 2 * threshold2)

171 a += level * factor[i];

172 else {

173 if (level > 0)

174 a += 2 * (level - (int)threshold1) * factor[i];

175 else

176 a += 2 * (level + (int)threshold1) * factor[i];

177 }

178 }

179 }

180 return (a + (1 << 11)) >> 12;

181 }

182

183 static int softthresh_c(PP7Context *p, int16_t *src, int qp)

184 {

185 int i;

186 int a;

187

188 a = src[0] * factor[0];

189 for (i = 1; i < 16; i++) {

190 unsigned int threshold1 = p->thres2[qp][i];

191 unsigned int threshold2 = threshold1 << 1;

192 int level = src[i];

193 if (((unsigned)(level + threshold1)) > threshold2) {

194 if (level > 0)

195 a += (level - (int)threshold1) * factor[i];

196 else

197 a += (level + (int)threshold1) * factor[i];

198 }

199 }

200 return (a + (1 << 11)) >> 12;

201 }

202

203 static void filter(PP7Context *p, uint8_t *dst, uint8_t *src,

204 int dst_stride, int src_stride,

205 int width, int height,

206 uint8_t *qp_store, int qp_stride, int is_luma)

207 {

208 int x, y;

209 const int stride = is_luma ? p->temp_stride : ((width + 16 + 15) & (~15));

210 uint8_t *p_src = p->src + 8 * stride;

211 int16_t *block = (int16_t *)p->src;

212 int16_t *temp = (int16_t *)(p->src + 32);

213

214 if (!src || !dst) return;

215 for (y = 0; y < height; y++) {

216 int index = 8 + 8 * stride + y * stride;

217 memcpy(p_src + index, src + y * src_stride, width);

218 for (x = 0; x < 8; x++) {

219 p_src[index - x - 1]= p_src[index + x ];

220 p_src[index + width + x ]= p_src[index + width - x - 1];

221 }

222 }

223 for (y = 0; y < 8; y++) {

224 memcpy(p_src + ( 7 - y ) * stride, p_src + ( y + 8 ) * stride, stride);

225 memcpy(p_src + (height + 8 + y) * stride, p_src + (height - y + 7) * stride, stride);

226 }

227 //FIXME (try edge emu)

228

229 for (y = 0; y < height; y++) {

230 for (x = -8; x < 0; x += 4) {

231 const int index = x + y * stride + (8 - 3) * (1 + stride) + 8; //FIXME silly offset

232 uint8_t *src = p_src + index;

233 int16_t *tp = temp + 4 * x;

234

235 dctA_c(tp + 4 * 8, src, stride);

236 }

237 for (x = 0; x < width; ) {

238 const int qps = 3 + is_luma;

239 int qp;

240 int end = FFMIN(x + 8, width);

241

242 if (p->qp)

243 qp = p->qp;

244 else {

245 qp = qp_store[ (FFMIN(x, width - 1) >> qps) + (FFMIN(y, height - 1) >> qps) * qp_stride];

246 qp = ff_norm_qscale(qp, p->qscale_type);

247 }

248 for (; x < end; x++) {

249 const int index = x + y * stride + (8 - 3) * (1 + stride) + 8; //FIXME silly offset

250 uint8_t *src = p_src + index;

251 int16_t *tp = temp + 4 * x;

252 int v;

253

254 if ((x & 3) == 0)

255 dctA_c(tp + 4 * 8, src, stride);

256

257 p->dctB(block, tp);

258

259 v = p->requantize(p, block, qp);

260 v = (v + dither[y & 7][x & 7]) >> 6;

261 if ((unsigned)v > 255)

262 v = (-v) >> 31;

263 dst[x + y * dst_stride] = v;

264 }

265 }

266 }

267 }

268

269 static const enum AVPixelFormat pix_fmts[] = {

270 AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P,

271 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P,

272 AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV440P,

273 AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P,

274 AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ440P,

275 AV_PIX_FMT_GBRP,

276 AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE

277 };

278

279 static int config_input(AVFilterLink *inlink)

280 {

281 AVFilterContext *ctx = inlink->dst;

282 PP7Context *pp7 = ctx->priv;

283 const int h = FFALIGN(inlink->h + 16, 16);

284 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);

285

286 pp7->hsub = desc->log2_chroma_w;

287 pp7->vsub = desc->log2_chroma_h;

288

289 pp7->temp_stride = FFALIGN(inlink->w + 16, 16);

290 pp7->src = av_malloc_array(pp7->temp_stride, (h + 8) * sizeof(uint8_t));

291

292 if (!pp7->src)

293 return AVERROR(ENOMEM);

294

295 init_thres2(pp7);

296

297 switch (pp7->mode) {

298 case 0: pp7->requantize = hardthresh_c; break;

299 case 1: pp7->requantize = softthresh_c; break;

300 default:

301 case 2: pp7->requantize = mediumthresh_c; break;

302 }

303

304 pp7->dctB = dctB_c;

305

306 #if ARCH_X86

307 ff_pp7_init_x86(pp7);

308 #endif

309

310 return 0;

311 }

312

313 static int filter_frame(AVFilterLink *inlink, AVFrame *in)

314 {

315 AVFilterContext *ctx = inlink->dst;

316 PP7Context *pp7 = ctx->priv;

317 AVFilterLink *outlink = ctx->outputs[0];

318 AVFrame *out = in;

319

320 int qp_stride = 0;

321 int8_t *qp_table = NULL;

322

323 if (!pp7->qp) {

324 int ret = ff_qp_table_extract(in, &qp_table, &qp_stride, NULL, &pp7->qscale_type);

325 if (ret < 0) {

326 av_frame_free(&in);

327 return ret;

328 }

329 }

330

331 if (!ctx->is_disabled) {

332 const int cw = AV_CEIL_RSHIFT(inlink->w, pp7->hsub);

333 const int ch = AV_CEIL_RSHIFT(inlink->h, pp7->vsub);

334

335 /* get a new frame if in-place is not possible or if the dimensions

336 * are not multiple of 8 */

337 if (!av_frame_is_writable(in) || (inlink->w & 7) || (inlink->h & 7)) {

338 const int aligned_w = FFALIGN(inlink->w, 8);

339 const int aligned_h = FFALIGN(inlink->h, 8);

340

341 out = ff_get_video_buffer(outlink, aligned_w, aligned_h);

342 if (!out) {

343 av_frame_free(&in);

344 av_freep(&qp_table);

345 return AVERROR(ENOMEM);

346 }

347 av_frame_copy_props(out, in);

348 out->width = in->width;

349 out->height = in->height;

350 }

351

352 if (qp_table || pp7->qp) {

353

354 filter(pp7, out->data[0], in->data[0], out->linesize[0], in->linesize[0],

355 inlink->w, inlink->h, qp_table, qp_stride, 1);

356 filter(pp7, out->data[1], in->data[1], out->linesize[1], in->linesize[1],

357 cw, ch, qp_table, qp_stride, 0);

358 filter(pp7, out->data[2], in->data[2], out->linesize[2], in->linesize[2],

359 cw, ch, qp_table, qp_stride, 0);

360 emms_c();

361 }

362 }

363

364 if (in != out) {

365 if (in->data[3])

366 av_image_copy_plane(out->data[3], out->linesize[3],

367 in ->data[3], in ->linesize[3],

368 inlink->w, inlink->h);

369 av_frame_free(&in);

370 }

371 av_freep(&qp_table);

372 return ff_filter_frame(outlink, out);

373 }

374

375 static av_cold void uninit(AVFilterContext *ctx)

376 {

377 PP7Context *pp7 = ctx->priv;

378 av_freep(&pp7->src);

379 }

380

381 static const AVFilterPad pp7_inputs[] = {

382 {

383 .name = "default",

384 .type = AVMEDIA_TYPE_VIDEO,

385 .config_props = config_input,

386 .filter_frame = filter_frame,

387 },

388 };

389

390 const AVFilter ff_vf_pp7 = {

391 .name = "pp7",

392 .description = NULL_IF_CONFIG_SMALL("Apply Postprocessing 7 filter."),

393 .priv_size = sizeof(PP7Context),

394 .uninit = uninit,

395 FILTER_INPUTS(pp7_inputs),

396 FILTER_OUTPUTS(ff_video_default_filterpad),

397 FILTER_PIXFMTS_ARRAY(pix_fmts),

398 .priv_class = &pp7_class,

399 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,

400 };

ff_get_video_buffer

AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)

Request a picture buffer with a specific set of permissions.

Definition: video.c:112

OFFSET

#define OFFSET(x)

Definition: vf_pp7.c:46

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

level

uint8_t level

Definition: svq3.c:204

qp_table.h

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

opt.h

mem_internal.h

out

FILE * out

Definition: movenc.c:54

ff_filter_frame

int ff_filter_frame(AVFilterLink *link, AVFrame *frame)

Send a frame of data to the next filter.

Definition: avfilter.c:1018

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:2962

FILTER_PIXFMTS_ARRAY

#define FILTER_PIXFMTS_ARRAY(array)

Definition: internal.h:162

inlink

The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink

Definition: filter_design.txt:212

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:130

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:344

pixdesc.h

AVFrame::width

int width

Definition: frame.h:416

pp7_options

static const AVOption pp7_options[]

Definition: vf_pp7.c:48

AVOption

AVOption.

Definition: opt.h:346

AV_PIX_FMT_YUV440P

@ AV_PIX_FMT_YUV440P

planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)

Definition: pixfmt.h:106

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

#define N2

Definition: vf_pp7.c:72

AVFilter::name

const char * name

Filter name.

Definition: avfilter.h:170

ff_norm_qscale

static int ff_norm_qscale(int qscale, enum AVVideoEncParamsType type)

Normalize the qscale factor FIXME Add support for other values of enum AVVideoEncParamsType besides A...

Definition: qp_table.h:39

MODE_HARD

@ MODE_HARD

Definition: vf_pp7.c:41

video.h

AVFilterLink

A link between two filters.

Definition: avfilter.h:542

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:365

av_image_copy_plane

void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)

Copy image plane from src to dst.

Definition: imgutils.c:374

init_thres2

static void init_thres2(PP7Context *p)

Definition: vf_pp7.c:85

PP7Context::requantize

int(* requantize)(struct PP7Context *p, int16_t *src, int qp)

Definition: vf_pp7.h:40

#define s3

Definition: regdef.h:40

softthresh_c

static int softthresh_c(PP7Context *p, int16_t *src, int qp)

Definition: vf_pp7.c:183

AVFILTER_DEFINE_CLASS

AVFILTER_DEFINE_CLASS(pp7)

dctB_c

static void dctB_c(int16_t *dst, int16_t *src)

Definition: vf_pp7.c:120

FLAGS

#define FLAGS

Definition: vf_pp7.c:47

AVFilterPad

A filter pad used for either input or output.

Definition: internal.h:33

SN0

#define SN0

Definition: vf_pp7.c:73

uninit

static av_cold void uninit(AVFilterContext *ctx)

Definition: vf_pp7.c:375

av_cold

#define av_cold

Definition: attributes.h:90

ff_video_default_filterpad

const AVFilterPad ff_video_default_filterpad[1]

An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_VIDEO.

Definition: video.c:37

hardthresh_c

static int hardthresh_c(PP7Context *p, int16_t *src, int qp)

Definition: vf_pp7.c:143

AV_PIX_FMT_YUVJ422P

@ AV_PIX_FMT_YUVJ422P

planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...

Definition: pixfmt.h:86

emms_c

#define emms_c()

Definition: emms.h:63

width

#define width

#define s(width, name)

Definition: cbs_vp9.c:198

AV_CEIL_RSHIFT

#define AV_CEIL_RSHIFT(a, b)

Definition: common.h:58

#define s1

Definition: regdef.h:38

ctx

AVFormatContext * ctx

Definition: movenc.c:48

filter

static void filter(PP7Context *p, uint8_t *dst, uint8_t *src, int dst_stride, int src_stride, int width, int height, uint8_t *qp_store, int qp_stride, int is_luma)

Definition: vf_pp7.c:203

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:73

ff_vf_pp7

const AVFilter ff_vf_pp7

Definition: vf_pp7.c:390

FILTER_INPUTS

#define FILTER_INPUTS(array)

Definition: internal.h:182

AV_PIX_FMT_YUVJ444P

@ AV_PIX_FMT_YUVJ444P

planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...

Definition: pixfmt.h:87

NULL

#define NULL

Definition: coverity.c:32

av_frame_copy_props

int av_frame_copy_props(AVFrame *dst, const AVFrame *src)

Copy only "metadata" fields from src to dst.

Definition: frame.c:679

bias

static int bias(int x, int c)

Definition: vqcdec.c:114

#define N

Definition: vf_pp7.c:76

AV_PIX_FMT_YUVJ420P

@ AV_PIX_FMT_YUVJ420P

planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...

Definition: pixfmt.h:85

mediumthresh_c

static int mediumthresh_c(PP7Context *p, int16_t *src, int qp)

Definition: vf_pp7.c:159

AV_PIX_FMT_GRAY8

@ AV_PIX_FMT_GRAY8

Y , 8bpp.

Definition: pixfmt.h:81

index

int index

Definition: gxfenc.c:89

PP7Context::temp_stride

int temp_stride

Definition: vf_pp7.h:37

#define s2

Definition: regdef.h:39

SN2

#define SN2

Definition: vf_pp7.c:75

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:106

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem_internal.h:109

#define N0

Definition: vf_pp7.c:70

dither

static const uint8_t dither[8][8]

Definition: vf_pp7.c:59

vf_pp7.h

av_frame_is_writable

int av_frame_is_writable(AVFrame *frame)

Check if the frame data is writable.

Definition: frame.c:615

filter_frame

static int filter_frame(AVFilterLink *inlink, AVFrame *in)

Definition: vf_pp7.c:313

height

#define height

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

dctA_c

static void dctA_c(int16_t *dst, uint8_t *src, int stride)

Definition: vf_pp7.c:97

PP7Context::hsub

int hsub

Definition: vf_pp7.h:35

internal.h

emms.h

PP7Context::qscale_type

enum AVVideoEncParamsType qscale_type

Definition: vf_pp7.h:34