FFmpeg
slice.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2015 Pedro Arthur <bygrandao@gmail.com>
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  */
20 
21 #include "swscale_internal.h"
22 
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  }
35 
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 }
40 
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};
49 
50  s->should_free_lines = 1;
51  s->width = width;
52 
53  for (i = 0; i < 2; ++i) {
54  int n = s->plane[i].available_lines;
55  int j;
56  int ii = idx[i];
57 
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  }
74 
75  return 0;
76 }
77 
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 };
85 
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;
91 
92  for (i = 0; i < 4; ++i) {
93  int n = size[i] * ( ring == 0 ? 1 : 3);
94  s->plane[i].line = av_mallocz_array(sizeof(uint8_t*), n);
95  if (!s->plane[i].line)
96  return AVERROR(ENOMEM);
97 
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 
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_mallocz_array(sizeof(SwsFilterDescriptor), c->numDesc);
288  if (!c->desc)
289  return AVERROR(ENOMEM);
290  c->slice = av_mallocz_array(sizeof(SwsSlice), c->numSlice);
291 
292 
293  res = alloc_slice(&c->slice[0], c->srcFormat, c->srcH, c->chrSrcH, c->chrSrcHSubSample, c->chrSrcVSubSample, 0);
294  if (res < 0) goto cleanup;
295  for (i = 1; i < c->numSlice-2; ++i) {
296  res = alloc_slice(&c->slice[i], c->srcFormat, lumBufSize, chrBufSize, c->chrSrcHSubSample, c->chrSrcVSubSample, 0);
297  if (res < 0) goto cleanup;
298  res = alloc_lines(&c->slice[i], FFALIGN(c->srcW*2+78, 16), c->srcW);
299  if (res < 0) goto cleanup;
300  }
301  // horizontal scaler output
302  res = alloc_slice(&c->slice[i], c->srcFormat, lumBufSize, chrBufSize, c->chrDstHSubSample, c->chrDstVSubSample, 1);
303  if (res < 0) goto cleanup;
304  res = alloc_lines(&c->slice[i], dst_stride, c->dstW);
305  if (res < 0) goto cleanup;
306 
307  fill_ones(&c->slice[i], dst_stride>>1, c->dstBpc);
308 
309  // vertical scaler output
310  ++i;
311  res = alloc_slice(&c->slice[i], c->dstFormat, c->dstH, c->chrDstH, c->chrDstHSubSample, c->chrDstVSubSample, 0);
312  if (res < 0) goto cleanup;
313 
314  index = 0;
315  srcIdx = 0;
316  dstIdx = 1;
317 
318  if (need_gamma) {
319  res = ff_init_gamma_convert(c->desc + index, c->slice + srcIdx, c->inv_gamma);
320  if (res < 0) goto cleanup;
321  ++index;
322  }
323 
324  if (need_lum_conv) {
325  res = ff_init_desc_fmt_convert(&c->desc[index], &c->slice[srcIdx], &c->slice[dstIdx], pal);
326  if (res < 0) goto cleanup;
327  c->desc[index].alpha = c->needAlpha;
328  ++index;
329  srcIdx = dstIdx;
330  }
331 
332 
333  dstIdx = FFMAX(num_ydesc, num_cdesc);
334  res = ff_init_desc_hscale(&c->desc[index], &c->slice[srcIdx], &c->slice[dstIdx], c->hLumFilter, c->hLumFilterPos, c->hLumFilterSize, c->lumXInc);
335  if (res < 0) goto cleanup;
336  c->desc[index].alpha = c->needAlpha;
337 
338 
339  ++index;
340  {
341  srcIdx = 0;
342  dstIdx = 1;
343  if (need_chr_conv) {
344  res = ff_init_desc_cfmt_convert(&c->desc[index], &c->slice[srcIdx], &c->slice[dstIdx], pal);
345  if (res < 0) goto cleanup;
346  ++index;
347  srcIdx = dstIdx;
348  }
349 
350  dstIdx = FFMAX(num_ydesc, num_cdesc);
351  if (c->needs_hcscale)
352  res = ff_init_desc_chscale(&c->desc[index], &c->slice[srcIdx], &c->slice[dstIdx], c->hChrFilter, c->hChrFilterPos, c->hChrFilterSize, c->chrXInc);
353  else
354  res = ff_init_desc_no_chr(&c->desc[index], &c->slice[srcIdx], &c->slice[dstIdx]);
355  if (res < 0) goto cleanup;
356  }
357 
358  ++index;
359  {
360  srcIdx = c->numSlice - 2;
361  dstIdx = c->numSlice - 1;
362  res = ff_init_vscale(c, c->desc + index, c->slice + srcIdx, c->slice + dstIdx);
363  if (res < 0) goto cleanup;
364  }
365 
366  ++index;
367  if (need_gamma) {
368  res = ff_init_gamma_convert(c->desc + index, c->slice + dstIdx, c->gamma);
369  if (res < 0) goto cleanup;
370  }
371 
372  return 0;
373 
374 cleanup:
376  return res;
377 }
378 
380 {
381  int i;
382  if (c->desc) {
383  for (i = 0; i < c->numDesc; ++i)
384  av_freep(&c->desc[i].instance);
385  av_freep(&c->desc);
386  }
387 
388  if (c->slice) {
389  for (i = 0; i < c->numSlice; ++i)
390  free_slice(&c->slice[i]);
391  av_freep(&c->slice);
392  }
393  return 0;
394 }
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
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:127
index
fg index
Definition: ffmpeg_filter.c:168
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
SwsFilterDescriptor
Struct which holds all necessary data for processing a slice.
Definition: swscale_internal.h:1001
isGray
#define isGray(x)
Definition: swscale.c:40
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:196
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
s
#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
c
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:830
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
size
int size
Definition: twinvq_data.h:10344
free_slice
static void free_slice(SwsSlice *s)
Definition: slice.c:106
i
int i
Definition: input.c:407
alloc_slice
static int alloc_slice(SwsSlice *s, enum AVPixelFormat fmt, int lumLines, int chrLines, int h_sub_sample, int v_sub_sample, int ring)
Definition: slice.c:78
ff_init_gamma_convert
int ff_init_gamma_convert(SwsFilterDescriptor *desc, SwsSlice *src, uint16_t *table)
initializes gamma conversion descriptor
Definition: gamma.c:58
ff_free_filters
int ff_free_filters(SwsContext *c)
Definition: slice.c:379
swscale_internal.h
SwsSlice
Struct which defines a slice of an image to be scaled or an output for a scaled slice.
Definition: swscale_internal.h:986
ff_init_slice_from_src
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)
Definition: slice.c:147
isPlanarYUV
static av_always_inline int isPlanarYUV(enum AVPixelFormat pix_fmt)
Definition: vf_dnn_processing.c:160
ff_init_vscale
int ff_init_vscale(SwsContext *c, SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst)
initializes vertical scaling descriptors
Definition: vscale.c:213
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
lum
static double lum(void *priv, double x, double y, int plane)
Definition: vf_fftfilt.c:95
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
ff_init_desc_fmt_convert
int ff_init_desc_fmt_convert(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint32_t *pal)
initializes lum pixel format conversion descriptor
Definition: hscale.c:127
int32_t
int32_t
Definition: audioconvert.c:56
SwsContext
Definition: swscale_internal.h:283
MAX_LINES_AHEAD
#define MAX_LINES_AHEAD
Definition: swscale_internal.h:1057