FFmpeg: libswscale/slice.c Source File

FFmpeg

[フレーム]

libswscale

slice.c

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

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

7 * modify it under the terms of the GNU Lesser General Public

8 * License as published by the Free Software Foundation; either

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

10 *

11 * FFmpeg 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 GNU

14 * Lesser General Public License for more details.

15 *

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

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

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

19 */

21 #include "swscale_internal.h"

23 static void free_lines(SwsSlice *s)

24 {

25 int i;

26 for (i = 0; i < 2; ++i) {

27 int n = s->plane[i].available_lines;

28 int j;

29 for (j = 0; j < n; ++j) {

30 av_freep(&s->plane[i].line[j]);

31 if (s->is_ring)

32 s->plane[i].line[j+n] = NULL;

33 }

34 }

36 for (i = 0; i < 4; ++i)

37 memset(s->plane[i].line, 0, sizeof(uint8_t*) * s->plane[i].available_lines * (s->is_ring ? 3 : 1));

38 s->should_free_lines = 0;

39 }

41 /*

42 slice lines contains extra bytes for vectorial code thus @size

43 is the allocated memory size and @width is the number of pixels

44 */

45 static int alloc_lines(SwsSlice *s, int size, int width)

46 {

47 int i;

48 int idx[2] = {3, 2};

50 s->should_free_lines = 1;

51 s->width = width;

53 for (i = 0; i < 2; ++i) {

54 int n = s->plane[i].available_lines;

55 int j;

56 int ii = idx[i];

58 av_assert0(n == s->plane[ii].available_lines);

59 for (j = 0; j < n; ++j) {

60 // chroma plane line U and V are expected to be contiguous in memory

61 // by mmx vertical scaler code

62 s->plane[i].line[j] = av_malloc(size * 2 + 32);

63 if (!s->plane[i].line[j]) {

64 free_lines(s);

65 return AVERROR(ENOMEM);

66 }

67 s->plane[ii].line[j] = s->plane[i].line[j] + size + 16;

68 if (s->is_ring) {

69 s->plane[i].line[j+n] = s->plane[i].line[j];

70 s->plane[ii].line[j+n] = s->plane[ii].line[j];

71 }

72 }

73 }

75 return 0;

76 }

78 static int alloc_slice(SwsSlice *s, enum AVPixelFormat fmt, int lumLines, int chrLines, int h_sub_sample, int v_sub_sample, int ring)

79 {

80 int i;

81 int size[4] = { lumLines,

82 chrLines,

83 chrLines,

84 lumLines };

86 s->h_chr_sub_sample = h_sub_sample;

87 s->v_chr_sub_sample = v_sub_sample;

88 s->fmt = fmt;

89 s->is_ring = ring;

90 s->should_free_lines = 0;

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

93 int n = size[i] * ( ring == 0 ? 1 : 3);

94 s->plane[i].line = av_calloc(n, sizeof(*s->plane[i].line));

95 if (!s->plane[i].line)

96 return AVERROR(ENOMEM);

98 s->plane[i].tmp = ring ? s->plane[i].line + size[i] * 2 : NULL;

99 s->plane[i].available_lines = size[i];

100 s->plane[i].sliceY = 0;

101 s->plane[i].sliceH = 0;

102 }

103 return 0;

104 }

105

106 static void free_slice(SwsSlice *s)

107 {

108 int i;

109 if (s) {

110 if (s->should_free_lines)

111 free_lines(s);

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

113 av_freep(&s->plane[i].line);

114 s->plane[i].tmp = NULL;

115 }

116 }

117 }

118

119 int ff_rotate_slice(SwsSlice *s, int lum, int chr)

120 {

121 int i;

122 if (lum) {

123 for (i = 0; i < 4; i+=3) {

124 int n = s->plane[i].available_lines;

125 int l = lum - s->plane[i].sliceY;

126

127 if (l >= n * 2) {

128 s->plane[i].sliceY += n;

129 s->plane[i].sliceH -= n;

130 }

131 }

132 }

133 if (chr) {

134 for (i = 1; i < 3; ++i) {

135 int n = s->plane[i].available_lines;

136 int l = chr - s->plane[i].sliceY;

137

138 if (l >= n * 2) {

139 s->plane[i].sliceY += n;

140 s->plane[i].sliceH -= n;

141 }

142 }

143 }

144 return 0;

145 }

146

147 int ff_init_slice_from_src(SwsSlice * s, uint8_t *src[4], int stride[4], int srcW, int lumY, int lumH, int chrY, int chrH, int relative)

148 {

149 int i = 0;

150

151 const int start[4] = {lumY,

152 chrY,

153 chrY,

154 lumY};

155

156 const int end[4] = {lumY +lumH,

157 chrY + chrH,

158 chrY + chrH,

159 lumY + lumH};

160

161 s->width = srcW;

162

163 for (i = 0; i < 4 && src[i] != NULL; ++i) {

164 uint8_t *const src_i = src[i] + (relative ? 0 : start[i]) * stride[i];

165 int j;

166 int first = s->plane[i].sliceY;

167 int n = s->plane[i].available_lines;

168 int lines = end[i] - start[i];

169 int tot_lines = end[i] - first;

170

171 if (start[i] >= first && n >= tot_lines) {

172 s->plane[i].sliceH = FFMAX(tot_lines, s->plane[i].sliceH);

173 for (j = 0; j < lines; j+= 1)

174 s->plane[i].line[start[i] - first + j] = src_i + j * stride[i];

175 } else {

176 s->plane[i].sliceY = start[i];

177 lines = lines > n ? n : lines;

178 s->plane[i].sliceH = lines;

179 for (j = 0; j < lines; j+= 1)

180 s->plane[i].line[j] = src_i + j * stride[i];

181 }

182

183 }

184

185 return 0;

186 }

187

188 static void fill_ones(SwsSlice *s, int n, int bpc)

189 {

190 int i, j, k, size, end;

191

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

193 size = s->plane[i].available_lines;

194 for (j = 0; j < size; ++j) {

195 if (bpc == 16) {

196 end = (n>>1) + 1;

197 for (k = 0; k < end; ++k)

198 ((int32_t*)(s->plane[i].line[j]))[k] = 1<<18;

199 } else if (bpc == 32) {

200 end = (n>>2) + 1;

201 for (k = 0; k < end; ++k)

202 ((int64_t*)(s->plane[i].line[j]))[k] = 1LL<<34;

203 } else {

204 end = n + 1;

205 for (k = 0; k < end; ++k)

206 ((int16_t*)(s->plane[i].line[j]))[k] = 1<<14;

207 }

208 }

209 }

210 }

211

212 /*

213 Calculates the minimum ring buffer size, it should be able to store vFilterSize

214 more n lines where n is the max difference between each adjacent slice which

215 outputs a line.

216 The n lines are needed only when there is not enough src lines to output a single

217 dst line, then we should buffer these lines to process them on the next call to scale.

218 */

219 static void get_min_buffer_size(SwsContext *c, int *out_lum_size, int *out_chr_size)

220 {

221 int lumY;

222 int dstH = c->dstH;

223 int chrDstH = c->chrDstH;

224 int *lumFilterPos = c->vLumFilterPos;

225 int *chrFilterPos = c->vChrFilterPos;

226 int lumFilterSize = c->vLumFilterSize;

227 int chrFilterSize = c->vChrFilterSize;

228 int chrSubSample = c->chrSrcVSubSample;

229

230 *out_lum_size = lumFilterSize;

231 *out_chr_size = chrFilterSize;

232

233 for (lumY = 0; lumY < dstH; lumY++) {

234 int chrY = (int64_t)lumY * chrDstH / dstH;

235 int nextSlice = FFMAX(lumFilterPos[lumY] + lumFilterSize - 1,

236 ((chrFilterPos[chrY] + chrFilterSize - 1)

237 << chrSubSample));

238

239 nextSlice >>= chrSubSample;

240 nextSlice <<= chrSubSample;

241 (*out_lum_size) = FFMAX((*out_lum_size), nextSlice - lumFilterPos[lumY]);

242 (*out_chr_size) = FFMAX((*out_chr_size), (nextSlice >> chrSubSample) - chrFilterPos[chrY]);

243 }

244 }

245

246

247

248 int ff_init_filters(SwsContext * c)

249 {

250 int i;

251 int index;

252 int num_ydesc;

253 int num_cdesc;

254 int num_vdesc = isPlanarYUV(c->dstFormat) && !isGray(c->dstFormat) ? 2 : 1;

255 int need_lum_conv = c->lumToYV12 || c->readLumPlanar || c->alpToYV12 || c->readAlpPlanar;

256 int need_chr_conv = c->chrToYV12 || c->readChrPlanar;

257 int need_gamma = c->is_internal_gamma;

258 int srcIdx, dstIdx;

259 int dst_stride = FFALIGN(c->dstW * sizeof(int16_t) + 66, 16);

260

261 uint32_t * pal = usePal(c->srcFormat) ? c->pal_yuv : (uint32_t*)c->input_rgb2yuv_table;

262 int res = 0;

263

264 int lumBufSize;

265 int chrBufSize;

266

267 get_min_buffer_size(c, &lumBufSize, &chrBufSize);

268 lumBufSize = FFMAX(lumBufSize, c->vLumFilterSize + MAX_LINES_AHEAD);

269 chrBufSize = FFMAX(chrBufSize, c->vChrFilterSize + MAX_LINES_AHEAD);

270

271 if (c->dstBpc == 16)

272 dst_stride <<= 1;

273

274 if (c->dstBpc == 32)

275 dst_stride <<= 2;

276

277 num_ydesc = need_lum_conv ? 2 : 1;

278 num_cdesc = need_chr_conv ? 2 : 1;

279

280 c->numSlice = FFMAX(num_ydesc, num_cdesc) + 2;

281 c->numDesc = num_ydesc + num_cdesc + num_vdesc + (need_gamma ? 2 : 0);

282 c->descIndex[0] = num_ydesc + (need_gamma ? 1 : 0);

283 c->descIndex[1] = num_ydesc + num_cdesc + (need_gamma ? 1 : 0);

284

285

286

287 c->desc = av_calloc(c->numDesc, sizeof(*c->desc));

288 if (!c->desc)

289 return AVERROR(ENOMEM);

290 c->slice = av_calloc(c->numSlice, sizeof(*c->slice));

291 if (!c->slice) {

292 res = AVERROR(ENOMEM);

293 goto cleanup;

294 }

295

296 res = alloc_slice(&c->slice[0], c->srcFormat, c->srcH, c->chrSrcH, c->chrSrcHSubSample, c->chrSrcVSubSample, 0);

297 if (res < 0) goto cleanup;

298 for (i = 1; i < c->numSlice-2; ++i) {

299 res = alloc_slice(&c->slice[i], c->srcFormat, lumBufSize, chrBufSize, c->chrSrcHSubSample, c->chrSrcVSubSample, 0);

300 if (res < 0) goto cleanup;

301 res = alloc_lines(&c->slice[i], FFALIGN(c->srcW*2+78, 16), c->srcW);

302 if (res < 0) goto cleanup;

303 }

304 // horizontal scaler output

305 res = alloc_slice(&c->slice[i], c->srcFormat, lumBufSize, chrBufSize, c->chrDstHSubSample, c->chrDstVSubSample, 1);

306 if (res < 0) goto cleanup;

307 res = alloc_lines(&c->slice[i], dst_stride, c->dstW);

308 if (res < 0) goto cleanup;

309

310 fill_ones(&c->slice[i], dst_stride>>1, c->dstBpc);

311

312 // vertical scaler output

313 ++i;

314 res = alloc_slice(&c->slice[i], c->dstFormat, c->dstH, c->chrDstH, c->chrDstHSubSample, c->chrDstVSubSample, 0);

315 if (res < 0) goto cleanup;

316

317 index = 0;

318 srcIdx = 0;

319 dstIdx = 1;

320

321 if (need_gamma) {

322 res = ff_init_gamma_convert(c->desc + index, c->slice + srcIdx, c->inv_gamma);

323 if (res < 0) goto cleanup;

324 ++index;

325 }

326

327 if (need_lum_conv) {

328 res = ff_init_desc_fmt_convert(&c->desc[index], &c->slice[srcIdx], &c->slice[dstIdx], pal);

329 if (res < 0) goto cleanup;

330 c->desc[index].alpha = c->needAlpha;

331 ++index;

332 srcIdx = dstIdx;

333 }

334

335

336 dstIdx = FFMAX(num_ydesc, num_cdesc);

337 res = ff_init_desc_hscale(&c->desc[index], &c->slice[srcIdx], &c->slice[dstIdx], c->hLumFilter, c->hLumFilterPos, c->hLumFilterSize, c->lumXInc);

338 if (res < 0) goto cleanup;

339 c->desc[index].alpha = c->needAlpha;

340

341

342 ++index;

343 {

344 srcIdx = 0;

345 dstIdx = 1;

346 if (need_chr_conv) {

347 res = ff_init_desc_cfmt_convert(&c->desc[index], &c->slice[srcIdx], &c->slice[dstIdx], pal);

348 if (res < 0) goto cleanup;

349 ++index;

350 srcIdx = dstIdx;

351 }

352

353 dstIdx = FFMAX(num_ydesc, num_cdesc);

354 if (c->needs_hcscale)

355 res = ff_init_desc_chscale(&c->desc[index], &c->slice[srcIdx], &c->slice[dstIdx], c->hChrFilter, c->hChrFilterPos, c->hChrFilterSize, c->chrXInc);

356 else

357 res = ff_init_desc_no_chr(&c->desc[index], &c->slice[srcIdx], &c->slice[dstIdx]);

358 if (res < 0) goto cleanup;

359 }

360

361 ++index;

362 {

363 srcIdx = c->numSlice - 2;

364 dstIdx = c->numSlice - 1;

365 res = ff_init_vscale(c, c->desc + index, c->slice + srcIdx, c->slice + dstIdx);

366 if (res < 0) goto cleanup;

367 }

368

369 ++index;

370 if (need_gamma) {

371 res = ff_init_gamma_convert(c->desc + index, c->slice + dstIdx, c->gamma);

372 if (res < 0) goto cleanup;

373 }

374

375 return 0;

376

377 cleanup:

378 ff_free_filters(c);

379 return res;

380 }

381

382 int ff_free_filters(SwsContext *c)

383 {

384 int i;

385 if (c->desc) {

386 for (i = 0; i < c->numDesc; ++i)

387 av_freep(&c->desc[i].instance);

388 av_freep(&c->desc);

389 }

390

391 if (c->slice) {

392 for (i = 0; i < c->numSlice; ++i)

393 free_slice(&c->slice[i]);

394 av_freep(&c->slice);

395 }

396 return 0;

397 }

ff_init_desc_cfmt_convert

int ff_init_desc_cfmt_convert(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint32_t *pal)

initializes chr pixel format conversion descriptor

Definition: hscale.c:235

stride

int stride

Definition: mace.c:144

AVPixelFormat

Pixel format.

Definition: pixfmt.h:64

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

fill_ones

static void fill_ones(SwsSlice *s, int n, int bpc)

Definition: slice.c:188

get_min_buffer_size

static void get_min_buffer_size(SwsContext *c, int *out_lum_size, int *out_chr_size)

Definition: slice.c:219

ff_rotate_slice

int ff_rotate_slice(SwsSlice *s, int lum, int chr)

Definition: slice.c:119

cleanup

static av_cold void cleanup(FlashSV2Context *s)

Definition: flashsv2enc.c:128

index

fg index

Definition: ffmpeg_filter.c:167

ff_init_desc_hscale

int ff_init_desc_hscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int *filter_pos, int filter_size, int xInc)

initializes lum horizontal scaling descriptor

Definition: hscale.c:144

isGray

#define isGray(x)

Definition: swscale.c:40

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

ff_init_desc_no_chr

int ff_init_desc_no_chr(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst)

Definition: hscale.c:281

ff_init_filters

int ff_init_filters(SwsContext *c)

Definition: slice.c:248

first

trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first

Definition: rate_distortion.txt:12

width

#define width

#define s(width, name)

Definition: cbs_vp9.c:257

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

NULL

#define NULL

Definition: coverity.c:32

src

#define src

Definition: vp8dsp.c:255

ff_init_desc_chscale

int ff_init_desc_chscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int *filter_pos, int filter_size, int xInc)

initializes chr horizontal scaling descriptor

Definition: hscale.c:250

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

free_lines

static void free_lines(SwsSlice *s)

Definition: slice.c:23

alloc_lines

static int alloc_lines(SwsSlice *s, int size, int width)

Definition: slice.c:45

usePal

static av_always_inline int usePal(enum AVPixelFormat pix_fmt)

Definition: swscale_internal.h:880

size

int size