slice.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392
  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. #include "swscale_internal.h"
  21. static void free_lines(SwsSlice *s)
  22. {
  23. int i;
  24. for (i = 0; i < 2; ++i) {
  25. int n = s->plane[i].available_lines;
  26. int j;
  27. for (j = 0; j < n; ++j) {
  28. av_freep(&s->plane[i].line[j]);
  29. if (s->is_ring)
  30. s->plane[i].line[j+n] = NULL;
  31. }
  32. }
  33. for (i = 0; i < 4; ++i)
  34. memset(s->plane[i].line, 0, sizeof(uint8_t*) * s->plane[i].available_lines * (s->is_ring ? 3 : 1));
  35. s->should_free_lines = 0;
  36. }
  37. /*
  38. slice lines contains extra bytes for vectorial code thus @size
  39. is the allocated memory size and @width is the number of pixels
  40. */
  41. static int alloc_lines(SwsSlice *s, int size, int width)
  42. {
  43. int i;
  44. int idx[2] = {3, 2};
  45. s->should_free_lines = 1;
  46. s->width = width;
  47. for (i = 0; i < 2; ++i) {
  48. int n = s->plane[i].available_lines;
  49. int j;
  50. int ii = idx[i];
  51. av_assert0(n == s->plane[ii].available_lines);
  52. for (j = 0; j < n; ++j) {
  53. // chroma plane line U and V are expected to be contiguous in memory
  54. // by mmx vertical scaler code
  55. s->plane[i].line[j] = av_malloc(size * 2 + 32);
  56. if (!s->plane[i].line[j]) {
  57. free_lines(s);
  58. return AVERROR(ENOMEM);
  59. }
  60. s->plane[ii].line[j] = s->plane[i].line[j] + size + 16;
  61. if (s->is_ring) {
  62. s->plane[i].line[j+n] = s->plane[i].line[j];
  63. s->plane[ii].line[j+n] = s->plane[ii].line[j];
  64. }
  65. }
  66. }
  67. return 0;
  68. }
  69. static int alloc_slice(SwsSlice *s, enum AVPixelFormat fmt, int lumLines, int chrLines, int h_sub_sample, int v_sub_sample, int ring)
  70. {
  71. int i;
  72. int size[4] = { lumLines,
  73. chrLines,
  74. chrLines,
  75. lumLines };
  76. s->h_chr_sub_sample = h_sub_sample;
  77. s->v_chr_sub_sample = v_sub_sample;
  78. s->fmt = fmt;
  79. s->is_ring = ring;
  80. s->should_free_lines = 0;
  81. for (i = 0; i < 4; ++i) {
  82. int n = size[i] * ( ring == 0 ? 1 : 3);
  83. s->plane[i].line = av_mallocz_array(sizeof(uint8_t*), n);
  84. if (!s->plane[i].line)
  85. return AVERROR(ENOMEM);
  86. s->plane[i].tmp = ring ? s->plane[i].line + size[i] * 2 : NULL;
  87. s->plane[i].available_lines = size[i];
  88. s->plane[i].sliceY = 0;
  89. s->plane[i].sliceH = 0;
  90. }
  91. return 0;
  92. }
  93. static void free_slice(SwsSlice *s)
  94. {
  95. int i;
  96. if (s) {
  97. if (s->should_free_lines)
  98. free_lines(s);
  99. for (i = 0; i < 4; ++i) {
  100. av_freep(&s->plane[i].line);
  101. s->plane[i].tmp = NULL;
  102. }
  103. }
  104. }
  105. int ff_rotate_slice(SwsSlice *s, int lum, int chr)
  106. {
  107. int i;
  108. if (lum) {
  109. for (i = 0; i < 4; i+=3) {
  110. int n = s->plane[i].available_lines;
  111. int l = lum - s->plane[i].sliceY;
  112. if (l >= n * 2) {
  113. s->plane[i].sliceY += n;
  114. s->plane[i].sliceH -= n;
  115. }
  116. }
  117. }
  118. if (chr) {
  119. for (i = 1; i < 3; ++i) {
  120. int n = s->plane[i].available_lines;
  121. int l = chr - s->plane[i].sliceY;
  122. if (l >= n * 2) {
  123. s->plane[i].sliceY += n;
  124. s->plane[i].sliceH -= n;
  125. }
  126. }
  127. }
  128. return 0;
  129. }
  130. 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)
  131. {
  132. int i = 0;
  133. const int start[4] = {lumY,
  134. chrY,
  135. chrY,
  136. lumY};
  137. const int end[4] = {lumY +lumH,
  138. chrY + chrH,
  139. chrY + chrH,
  140. lumY + lumH};
  141. uint8_t *const src_[4] = {src[0] + (relative ? 0 : start[0]) * stride[0],
  142. src[1] + (relative ? 0 : start[1]) * stride[1],
  143. src[2] + (relative ? 0 : start[2]) * stride[2],
  144. src[3] + (relative ? 0 : start[3]) * stride[3]};
  145. s->width = srcW;
  146. for (i = 0; i < 4; ++i) {
  147. int j;
  148. int first = s->plane[i].sliceY;
  149. int n = s->plane[i].available_lines;
  150. int lines = end[i] - start[i];
  151. int tot_lines = end[i] - first;
  152. if (start[i] >= first && n >= tot_lines) {
  153. s->plane[i].sliceH = FFMAX(tot_lines, s->plane[i].sliceH);
  154. for (j = 0; j < lines; j+= 1)
  155. s->plane[i].line[start[i] - first + j] = src_[i] + j * stride[i];
  156. } else {
  157. s->plane[i].sliceY = start[i];
  158. lines = lines > n ? n : lines;
  159. s->plane[i].sliceH = lines;
  160. for (j = 0; j < lines; j+= 1)
  161. s->plane[i].line[j] = src_[i] + j * stride[i];
  162. }
  163. }
  164. return 0;
  165. }
  166. static void fill_ones(SwsSlice *s, int n, int is16bit)
  167. {
  168. int i;
  169. for (i = 0; i < 4; ++i) {
  170. int j;
  171. int size = s->plane[i].available_lines;
  172. for (j = 0; j < size; ++j) {
  173. int k;
  174. int end = is16bit ? n>>1: n;
  175. // fill also one extra element
  176. end += 1;
  177. if (is16bit)
  178. for (k = 0; k < end; ++k)
  179. ((int32_t*)(s->plane[i].line[j]))[k] = 1<<18;
  180. else
  181. for (k = 0; k < end; ++k)
  182. ((int16_t*)(s->plane[i].line[j]))[k] = 1<<14;
  183. }
  184. }
  185. }
  186. /*
  187. Calculates the minimum ring buffer size, it should be able to store vFilterSize
  188. more n lines where n is the max difference between each adjacent slice which
  189. outputs a line.
  190. The n lines are needed only when there is not enough src lines to output a single
  191. dst line, then we should buffer these lines to process them on the next call to scale.
  192. */
  193. static void get_min_buffer_size(SwsContext *c, int *out_lum_size, int *out_chr_size)
  194. {
  195. int lumY;
  196. int dstH = c->dstH;
  197. int chrDstH = c->chrDstH;
  198. int *lumFilterPos = c->vLumFilterPos;
  199. int *chrFilterPos = c->vChrFilterPos;
  200. int lumFilterSize = c->vLumFilterSize;
  201. int chrFilterSize = c->vChrFilterSize;
  202. int chrSubSample = c->chrSrcVSubSample;
  203. *out_lum_size = lumFilterSize;
  204. *out_chr_size = chrFilterSize;
  205. for (lumY = 0; lumY < dstH; lumY++) {
  206. int chrY = (int64_t)lumY * chrDstH / dstH;
  207. int nextSlice = FFMAX(lumFilterPos[lumY] + lumFilterSize - 1,
  208. ((chrFilterPos[chrY] + chrFilterSize - 1)
  209. << chrSubSample));
  210. nextSlice >>= chrSubSample;
  211. nextSlice <<= chrSubSample;
  212. (*out_lum_size) = FFMAX((*out_lum_size), nextSlice - lumFilterPos[lumY]);
  213. (*out_chr_size) = FFMAX((*out_chr_size), (nextSlice >> chrSubSample) - chrFilterPos[chrY]);
  214. }
  215. }
  216. int ff_init_filters(SwsContext * c)
  217. {
  218. int i;
  219. int index;
  220. int num_ydesc;
  221. int num_cdesc;
  222. int num_vdesc = isPlanarYUV(c->dstFormat) && !isGray(c->dstFormat) ? 2 : 1;
  223. int need_lum_conv = c->lumToYV12 || c->readLumPlanar || c->alpToYV12 || c->readAlpPlanar;
  224. int need_chr_conv = c->chrToYV12 || c->readChrPlanar;
  225. int need_gamma = c->is_internal_gamma;
  226. int srcIdx, dstIdx;
  227. int dst_stride = FFALIGN(c->dstW * sizeof(int16_t) + 66, 16);
  228. uint32_t * pal = usePal(c->srcFormat) ? c->pal_yuv : (uint32_t*)c->input_rgb2yuv_table;
  229. int res = 0;
  230. int lumBufSize;
  231. int chrBufSize;
  232. get_min_buffer_size(c, &lumBufSize, &chrBufSize);
  233. lumBufSize = FFMAX(lumBufSize, c->vLumFilterSize + MAX_LINES_AHEAD);
  234. chrBufSize = FFMAX(chrBufSize, c->vChrFilterSize + MAX_LINES_AHEAD);
  235. if (c->dstBpc == 16)
  236. dst_stride <<= 1;
  237. num_ydesc = need_lum_conv ? 2 : 1;
  238. num_cdesc = need_chr_conv ? 2 : 1;
  239. c->numSlice = FFMAX(num_ydesc, num_cdesc) + 2;
  240. c->numDesc = num_ydesc + num_cdesc + num_vdesc + (need_gamma ? 2 : 0);
  241. c->descIndex[0] = num_ydesc + (need_gamma ? 1 : 0);
  242. c->descIndex[1] = num_ydesc + num_cdesc + (need_gamma ? 1 : 0);
  243. c->desc = av_mallocz_array(sizeof(SwsFilterDescriptor), c->numDesc);
  244. if (!c->desc)
  245. return AVERROR(ENOMEM);
  246. c->slice = av_mallocz_array(sizeof(SwsSlice), c->numSlice);
  247. res = alloc_slice(&c->slice[0], c->srcFormat, c->srcH, c->chrSrcH, c->chrSrcHSubSample, c->chrSrcVSubSample, 0);
  248. if (res < 0) goto cleanup;
  249. for (i = 1; i < c->numSlice-2; ++i) {
  250. res = alloc_slice(&c->slice[i], c->srcFormat, lumBufSize, chrBufSize, c->chrSrcHSubSample, c->chrSrcVSubSample, 0);
  251. if (res < 0) goto cleanup;
  252. res = alloc_lines(&c->slice[i], FFALIGN(c->srcW*2+78, 16), c->srcW);
  253. if (res < 0) goto cleanup;
  254. }
  255. // horizontal scaler output
  256. res = alloc_slice(&c->slice[i], c->srcFormat, lumBufSize, chrBufSize, c->chrDstHSubSample, c->chrDstVSubSample, 1);
  257. if (res < 0) goto cleanup;
  258. res = alloc_lines(&c->slice[i], dst_stride, c->dstW);
  259. if (res < 0) goto cleanup;
  260. fill_ones(&c->slice[i], dst_stride>>1, c->dstBpc == 16);
  261. // vertical scaler output
  262. ++i;
  263. res = alloc_slice(&c->slice[i], c->dstFormat, c->dstH, c->chrDstH, c->chrDstHSubSample, c->chrDstVSubSample, 0);
  264. if (res < 0) goto cleanup;
  265. index = 0;
  266. srcIdx = 0;
  267. dstIdx = 1;
  268. if (need_gamma) {
  269. res = ff_init_gamma_convert(c->desc + index, c->slice + srcIdx, c->inv_gamma);
  270. if (res < 0) goto cleanup;
  271. ++index;
  272. }
  273. if (need_lum_conv) {
  274. res = ff_init_desc_fmt_convert(&c->desc[index], &c->slice[srcIdx], &c->slice[dstIdx], pal);
  275. if (res < 0) goto cleanup;
  276. c->desc[index].alpha = c->needAlpha;
  277. ++index;
  278. srcIdx = dstIdx;
  279. }
  280. dstIdx = FFMAX(num_ydesc, num_cdesc);
  281. res = ff_init_desc_hscale(&c->desc[index], &c->slice[srcIdx], &c->slice[dstIdx], c->hLumFilter, c->hLumFilterPos, c->hLumFilterSize, c->lumXInc);
  282. if (res < 0) goto cleanup;
  283. c->desc[index].alpha = c->needAlpha;
  284. ++index;
  285. {
  286. srcIdx = 0;
  287. dstIdx = 1;
  288. if (need_chr_conv) {
  289. res = ff_init_desc_cfmt_convert(&c->desc[index], &c->slice[srcIdx], &c->slice[dstIdx], pal);
  290. if (res < 0) goto cleanup;
  291. ++index;
  292. srcIdx = dstIdx;
  293. }
  294. dstIdx = FFMAX(num_ydesc, num_cdesc);
  295. if (c->needs_hcscale)
  296. res = ff_init_desc_chscale(&c->desc[index], &c->slice[srcIdx], &c->slice[dstIdx], c->hChrFilter, c->hChrFilterPos, c->hChrFilterSize, c->chrXInc);
  297. else
  298. res = ff_init_desc_no_chr(&c->desc[index], &c->slice[srcIdx], &c->slice[dstIdx]);
  299. if (res < 0) goto cleanup;
  300. }
  301. ++index;
  302. {
  303. srcIdx = c->numSlice - 2;
  304. dstIdx = c->numSlice - 1;
  305. res = ff_init_vscale(c, c->desc + index, c->slice + srcIdx, c->slice + dstIdx);
  306. if (res < 0) goto cleanup;
  307. }
  308. ++index;
  309. if (need_gamma) {
  310. res = ff_init_gamma_convert(c->desc + index, c->slice + dstIdx, c->gamma);
  311. if (res < 0) goto cleanup;
  312. }
  313. return 0;
  314. cleanup:
  315. ff_free_filters(c);
  316. return res;
  317. }
  318. int ff_free_filters(SwsContext *c)
  319. {
  320. int i;
  321. if (c->desc) {
  322. for (i = 0; i < c->numDesc; ++i)
  323. av_freep(&c->desc[i].instance);
  324. av_freep(&c->desc);
  325. }
  326. if (c->slice) {
  327. for (i = 0; i < c->numSlice; ++i)
  328. free_slice(&c->slice[i]);
  329. av_freep(&c->slice);
  330. }
  331. return 0;
  332. }