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  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:
379  return res;
380 }
381 
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
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
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:190
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
int32_t
int32_t
Definition: audio_convert.c:194
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
index
int index
Definition: gxfenc.c:89
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:382
swscale_internal.h
uint8_t
uint8_t
Definition: audio_convert.c:194
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
SwsContext
Definition: swscale_internal.h:283
MAX_LINES_AHEAD
#define MAX_LINES_AHEAD
Definition: swscale_internal.h:1057