Coverage Report

Created: 2022-08-24 06:11

/src/aom/av1/decoder/grain_synthesis.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
3
 *
4
 * This source code is subject to the terms of the BSD 2 Clause License and
5
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6
 * was not distributed with this source code in the LICENSE file, you can
7
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8
 * Media Patent License 1.0 was not distributed with this source code in the
9
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10
 */
11
12
/*!\file
13
 * \brief Describes film grain parameters and film grain synthesis
14
 *
15
 */
16
17
#include <stdio.h>
18
#include <string.h>
19
#include <stdlib.h>
20
#include <assert.h>
21
#include "aom_dsp/aom_dsp_common.h"
22
#include "aom_mem/aom_mem.h"
23
#include "av1/decoder/grain_synthesis.h"
24
25
// Samples with Gaussian distribution in the range of [-2048, 2047] (12 bits)
26
// with zero mean and standard deviation of about 512.
27
// should be divided by 4 for 10-bit range and 16 for 8-bit range.
28
static const int gaussian_sequence[2048] = {
29
  56,    568,   -180,  172,   124,   -84,   172,   -64,   -900,  24,   820,
30
  224,   1248,  996,   272,   -8,    -916,  -388,  -732,  -104,  -188, 800,
31
  112,   -652,  -320,  -376,  140,   -252,  492,   -168,  44,    -788, 588,
32
  -584,  500,   -228,  12,    680,   272,   -476,  972,   -100,  652,  368,
33
  432,   -196,  -720,  -192,  1000,  -332,  652,   -136,  -552,  -604, -4,
34
  192,   -220,  -136,  1000,  -52,   372,   -96,   -624,  124,   -24,  396,
35
  540,   -12,   -104,  640,   464,   244,   -208,  -84,   368,   -528, -740,
36
  248,   -968,  -848,  608,   376,   -60,   -292,  -40,   -156,  252,  -292,
37
  248,   224,   -280,  400,   -244,  244,   -60,   76,    -80,   212,  532,
38
  340,   128,   -36,   824,   -352,  -60,   -264,  -96,   -612,  416,  -704,
39
  220,   -204,  640,   -160,  1220,  -408,  900,   336,   20,    -336, -96,
40
  -792,  304,   48,    -28,   -1232, -1172, -448,  104,   -292,  -520, 244,
41
  60,    -948,  0,     -708,  268,   108,   356,   -548,  488,   -344, -136,
42
  488,   -196,  -224,  656,   -236,  -1128, 60,    4,     140,   276,  -676,
43
  -376,  168,   -108,  464,   8,     564,   64,    240,   308,   -300, -400,
44
  -456,  -136,  56,    120,   -408,  -116,  436,   504,   -232,  328,  844,
45
  -164,  -84,   784,   -168,  232,   -224,  348,   -376,  128,   568,  96,
46
  -1244, -288,  276,   848,   832,   -360,  656,   464,   -384,  -332, -356,
47
  728,   -388,  160,   -192,  468,   296,   224,   140,   -776,  -100, 280,
48
  4,     196,   44,    -36,   -648,  932,   16,    1428,  28,    528,  808,
49
  772,   20,    268,   88,    -332,  -284,  124,   -384,  -448,  208,  -228,
50
  -1044, -328,  660,   380,   -148,  -300,  588,   240,   540,   28,   136,
51
  -88,   -436,  256,   296,   -1000, 1400,  0,     -48,   1056,  -136, 264,
52
  -528,  -1108, 632,   -484,  -592,  -344,  796,   124,   -668,  -768, 388,
53
  1296,  -232,  -188,  -200,  -288,  -4,    308,   100,   -168,  256,  -500,
54
  204,   -508,  648,   -136,  372,   -272,  -120,  -1004, -552,  -548, -384,
55
  548,   -296,  428,   -108,  -8,    -912,  -324,  -224,  -88,   -112, -220,
56
  -100,  996,   -796,  548,   360,   -216,  180,   428,   -200,  -212, 148,
57
  96,    148,   284,   216,   -412,  -320,  120,   -300,  -384,  -604, -572,
58
  -332,  -8,    -180,  -176,  696,   116,   -88,   628,   76,    44,   -516,
59
  240,   -208,  -40,   100,   -592,  344,   -308,  -452,  -228,  20,   916,
60
  -1752, -136,  -340,  -804,  140,   40,    512,   340,   248,   184,  -492,
61
  896,   -156,  932,   -628,  328,   -688,  -448,  -616,  -752,  -100, 560,
62
  -1020, 180,   -800,  -64,   76,    576,   1068,  396,   660,   552,  -108,
63
  -28,   320,   -628,  312,   -92,   -92,   -472,  268,   16,    560,  516,
64
  -672,  -52,   492,   -100,  260,   384,   284,   292,   304,   -148, 88,
65
  -152,  1012,  1064,  -228,  164,   -376,  -684,  592,   -392,  156,  196,
66
  -524,  -64,   -884,  160,   -176,  636,   648,   404,   -396,  -436, 864,
67
  424,   -728,  988,   -604,  904,   -592,  296,   -224,  536,   -176, -920,
68
  436,   -48,   1176,  -884,  416,   -776,  -824,  -884,  524,   -548, -564,
69
  -68,   -164,  -96,   692,   364,   -692,  -1012, -68,   260,   -480, 876,
70
  -1116, 452,   -332,  -352,  892,   -1088, 1220,  -676,  12,    -292, 244,
71
  496,   372,   -32,   280,   200,   112,   -440,  -96,   24,    -644, -184,
72
  56,    -432,  224,   -980,  272,   -260,  144,   -436,  420,   356,  364,
73
  -528,  76,    172,   -744,  -368,  404,   -752,  -416,  684,   -688, 72,
74
  540,   416,   92,    444,   480,   -72,   -1416, 164,   -1172, -68,  24,
75
  424,   264,   1040,  128,   -912,  -524,  -356,  64,    876,   -12,  4,
76
  -88,   532,   272,   -524,  320,   276,   -508,  940,   24,    -400, -120,
77
  756,   60,    236,   -412,  100,   376,   -484,  400,   -100,  -740, -108,
78
  -260,  328,   -268,  224,   -200,  -416,  184,   -604,  -564,  -20,  296,
79
  60,    892,   -888,  60,    164,   68,    -760,  216,   -296,  904,  -336,
80
  -28,   404,   -356,  -568,  -208,  -1480, -512,  296,   328,   -360, -164,
81
  -1560, -776,  1156,  -428,  164,   -504,  -112,  120,   -216,  -148, -264,
82
  308,   32,    64,    -72,   72,    116,   176,   -64,   -272,  460,  -536,
83
  -784,  -280,  348,   108,   -752,  -132,  524,   -540,  -776,  116,  -296,
84
  -1196, -288,  -560,  1040,  -472,  116,   -848,  -1116, 116,   636,  696,
85
  284,   -176,  1016,  204,   -864,  -648,  -248,  356,   972,   -584, -204,
86
  264,   880,   528,   -24,   -184,  116,   448,   -144,  828,   524,  212,
87
  -212,  52,    12,    200,   268,   -488,  -404,  -880,  824,   -672, -40,
88
  908,   -248,  500,   716,   -576,  492,   -576,  16,    720,   -108, 384,
89
  124,   344,   280,   576,   -500,  252,   104,   -308,  196,   -188, -8,
90
  1268,  296,   1032,  -1196, 436,   316,   372,   -432,  -200,  -660, 704,
91
  -224,  596,   -132,  268,   32,    -452,  884,   104,   -1008, 424,  -1348,
92
  -280,  4,     -1168, 368,   476,   696,   300,   -8,    24,    180,  -592,
93
  -196,  388,   304,   500,   724,   -160,  244,   -84,   272,   -256, -420,
94
  320,   208,   -144,  -156,  156,   364,   452,   28,    540,   316,  220,
95
  -644,  -248,  464,   72,    360,   32,    -388,  496,   -680,  -48,  208,
96
  -116,  -408,  60,    -604,  -392,  548,   -840,  784,   -460,  656,  -544,
97
  -388,  -264,  908,   -800,  -628,  -612,  -568,  572,   -220,  164,  288,
98
  -16,   -308,  308,   -112,  -636,  -760,  280,   -668,  432,   364,  240,
99
  -196,  604,   340,   384,   196,   592,   -44,   -500,  432,   -580, -132,
100
  636,   -76,   392,   4,     -412,  540,   508,   328,   -356,  -36,  16,
101
  -220,  -64,   -248,  -60,   24,    -192,  368,   1040,  92,    -24,  -1044,
102
  -32,   40,    104,   148,   192,   -136,  -520,  56,    -816,  -224, 732,
103
  392,   356,   212,   -80,   -424,  -1008, -324,  588,   -1496, 576,  460,
104
  -816,  -848,  56,    -580,  -92,   -1372, -112,  -496,  200,   364,  52,
105
  -140,  48,    -48,   -60,   84,    72,    40,    132,   -356,  -268, -104,
106
  -284,  -404,  732,   -520,  164,   -304,  -540,  120,   328,   -76,  -460,
107
  756,   388,   588,   236,   -436,  -72,   -176,  -404,  -316,  -148, 716,
108
  -604,  404,   -72,   -88,   -888,  -68,   944,   88,    -220,  -344, 960,
109
  472,   460,   -232,  704,   120,   832,   -228,  692,   -508,  132,  -476,
110
  844,   -748,  -364,  -44,   1116,  -1104, -1056, 76,    428,   552,  -692,
111
  60,    356,   96,    -384,  -188,  -612,  -576,  736,   508,   892,  352,
112
  -1132, 504,   -24,   -352,  324,   332,   -600,  -312,  292,   508,  -144,
113
  -8,    484,   48,    284,   -260,  -240,  256,   -100,  -292,  -204, -44,
114
  472,   -204,  908,   -188,  -1000, -256,  92,    1164,  -392,  564,  356,
115
  652,   -28,   -884,  256,   484,   -192,  760,   -176,  376,   -524, -452,
116
  -436,  860,   -736,  212,   124,   504,   -476,  468,   76,    -472, 552,
117
  -692,  -944,  -620,  740,   -240,  400,   132,   20,    192,   -196, 264,
118
  -668,  -1012, -60,   296,   -316,  -828,  76,    -156,  284,   -768, -448,
119
  -832,  148,   248,   652,   616,   1236,  288,   -328,  -400,  -124, 588,
120
  220,   520,   -696,  1032,  768,   -740,  -92,   -272,  296,   448,  -464,
121
  412,   -200,  392,   440,   -200,  264,   -152,  -260,  320,   1032, 216,
122
  320,   -8,    -64,   156,   -1016, 1084,  1172,  536,   484,   -432, 132,
123
  372,   -52,   -256,  84,    116,   -352,  48,    116,   304,   -384, 412,
124
  924,   -300,  528,   628,   180,   648,   44,    -980,  -220,  1320, 48,
125
  332,   748,   524,   -268,  -720,  540,   -276,  564,   -344,  -208, -196,
126
  436,   896,   88,    -392,  132,   80,    -964,  -288,  568,   56,   -48,
127
  -456,  888,   8,     552,   -156,  -292,  948,   288,   128,   -716, -292,
128
  1192,  -152,  876,   352,   -600,  -260,  -812,  -468,  -28,   -120, -32,
129
  -44,   1284,  496,   192,   464,   312,   -76,   -516,  -380,  -456, -1012,
130
  -48,   308,   -156,  36,    492,   -156,  -808,  188,   1652,  68,   -120,
131
  -116,  316,   160,   -140,  352,   808,   -416,  592,   316,   -480, 56,
132
  528,   -204,  -568,  372,   -232,  752,   -344,  744,   -4,    324,  -416,
133
  -600,  768,   268,   -248,  -88,   -132,  -420,  -432,  80,    -288, 404,
134
  -316,  -1216, -588,  520,   -108,  92,    -320,  368,   -480,  -216, -92,
135
  1688,  -300,  180,   1020,  -176,  820,   -68,   -228,  -260,  436,  -904,
136
  20,    40,    -508,  440,   -736,  312,   332,   204,   760,   -372, 728,
137
  96,    -20,   -632,  -520,  -560,  336,   1076,  -64,   -532,  776,  584,
138
  192,   396,   -728,  -520,  276,   -188,  80,    -52,   -612,  -252, -48,
139
  648,   212,   -688,  228,   -52,   -260,  428,   -412,  -272,  -404, 180,
140
  816,   -796,  48,    152,   484,   -88,   -216,  988,   696,   188,  -528,
141
  648,   -116,  -180,  316,   476,   12,    -564,  96,    476,   -252, -364,
142
  -376,  -392,  556,   -256,  -576,  260,   -352,  120,   -16,   -136, -260,
143
  -492,  72,    556,   660,   580,   616,   772,   436,   424,   -32,  -324,
144
  -1268, 416,   -324,  -80,   920,   160,   228,   724,   32,    -516, 64,
145
  384,   68,    -128,  136,   240,   248,   -204,  -68,   252,   -932, -120,
146
  -480,  -628,  -84,   192,   852,   -404,  -288,  -132,  204,   100,  168,
147
  -68,   -196,  -868,  460,   1080,  380,   -80,   244,   0,     484,  -888,
148
  64,    184,   352,   600,   460,   164,   604,   -196,  320,   -64,  588,
149
  -184,  228,   12,    372,   48,    -848,  -344,  224,   208,   -200, 484,
150
  128,   -20,   272,   -468,  -840,  384,   256,   -720,  -520,  -464, -580,
151
  112,   -120,  644,   -356,  -208,  -608,  -528,  704,   560,   -424, 392,
152
  828,   40,    84,    200,   -152,  0,     -144,  584,   280,   -120, 80,
153
  -556,  -972,  -196,  -472,  724,   80,    168,   -32,   88,    160,  -688,
154
  0,     160,   356,   372,   -776,  740,   -128,  676,   -248,  -480, 4,
155
  -364,  96,    544,   232,   -1032, 956,   236,   356,   20,    -40,  300,
156
  24,    -676,  -596,  132,   1120,  -104,  532,   -1096, 568,   648,  444,
157
  508,   380,   188,   -376,  -604,  1488,  424,   24,    756,   -220, -192,
158
  716,   120,   920,   688,   168,   44,    -460,  568,   284,   1144, 1160,
159
  600,   424,   888,   656,   -356,  -320,  220,   316,   -176,  -724, -188,
160
  -816,  -628,  -348,  -228,  -380,  1012,  -452,  -660,  736,   928,  404,
161
  -696,  -72,   -268,  -892,  128,   184,   -344,  -780,  360,   336,  400,
162
  344,   428,   548,   -112,  136,   -228,  -216,  -820,  -516,  340,  92,
163
  -136,  116,   -300,  376,   -244,  100,   -316,  -520,  -284,  -12,  824,
164
  164,   -548,  -180,  -128,  116,   -924,  -828,  268,   -368,  -580, 620,
165
  192,   160,   0,     -1676, 1068,  424,   -56,   -360,  468,   -156, 720,
166
  288,   -528,  556,   -364,  548,   -148,  504,   316,   152,   -648, -620,
167
  -684,  -24,   -376,  -384,  -108,  -920,  -1032, 768,   180,   -264, -508,
168
  -1268, -260,  -60,   300,   -240,  988,   724,   -376,  -576,  -212, -736,
169
  556,   192,   1092,  -620,  -880,  376,   -56,   -4,    -216,  -32,  836,
170
  268,   396,   1332,  864,   -600,  100,   56,    -412,  -92,   356,  180,
171
  884,   -468,  -436,  292,   -388,  -804,  -704,  -840,  368,   -348, 140,
172
  -724,  1536,  940,   372,   112,   -372,  436,   -480,  1136,  296,  -32,
173
  -228,  132,   -48,   -220,  868,   -1016, -60,   -1044, -464,  328,  916,
174
  244,   12,    -736,  -296,  360,   468,   -376,  -108,  -92,   788,  368,
175
  -56,   544,   400,   -672,  -420,  728,   16,    320,   44,    -284, -380,
176
  -796,  488,   132,   204,   -596,  -372,  88,    -152,  -908,  -636, -572,
177
  -624,  -116,  -692,  -200,  -56,   276,   -88,   484,   -324,  948,  864,
178
  1000,  -456,  -184,  -276,  292,   -296,  156,   676,   320,   160,  908,
179
  -84,   -1236, -288,  -116,  260,   -372,  -644,  732,   -756,  -96,  84,
180
  344,   -520,  348,   -688,  240,   -84,   216,   -1044, -136,  -676, -396,
181
  -1500, 960,   -40,   176,   168,   1516,  420,   -504,  -344,  -364, -360,
182
  1216,  -940,  -380,  -212,  252,   -660,  -708,  484,   -444,  -152, 928,
183
  -120,  1112,  476,   -260,  560,   -148,  -344,  108,   -196,  228,  -288,
184
  504,   560,   -328,  -88,   288,   -1008, 460,   -228,  468,   -836, -196,
185
  76,    388,   232,   412,   -1168, -716,  -644,  756,   -172,  -356, -504,
186
  116,   432,   528,   48,    476,   -168,  -608,  448,   160,   -532, -272,
187
  28,    -676,  -12,   828,   980,   456,   520,   104,   -104,  256,  -344,
188
  -4,    -28,   -368,  -52,   -524,  -572,  -556,  -200,  768,   1124, -208,
189
  -512,  176,   232,   248,   -148,  -888,  604,   -600,  -304,  804,  -156,
190
  -212,  488,   -192,  -804,  -256,  368,   -360,  -916,  -328,  228,  -240,
191
  -448,  -472,  856,   -556,  -364,  572,   -12,   -156,  -368,  -340, 432,
192
  252,   -752,  -152,  288,   268,   -580,  -848,  -592,  108,   -76,  244,
193
  312,   -716,  592,   -80,   436,   360,   4,     -248,  160,   516,  584,
194
  732,   44,    -468,  -280,  -292,  -156,  -588,  28,    308,   912,  24,
195
  124,   156,   180,   -252,  944,   -924,  -772,  -520,  -428,  -624, 300,
196
  -212,  -1144, 32,    -724,  800,   -1128, -212,  -1288, -848,  180,  -416,
197
  440,   192,   -576,  -792,  -76,   -1080, 80,    -532,  -352,  -132, 380,
198
  -820,  148,   1112,  128,   164,   456,   700,   -924,  144,   -668, -384,
199
  648,   -832,  508,   552,   -52,   -100,  -656,  208,   -568,  748,  -88,
200
  680,   232,   300,   192,   -408,  -1012, -152,  -252,  -268,  272,  -876,
201
  -664,  -648,  -332,  -136,  16,    12,    1152,  -28,   332,   -536, 320,
202
  -672,  -460,  -316,  532,   -260,  228,   -40,   1052,  -816,  180,  88,
203
  -496,  -556,  -672,  -368,  428,   92,    356,   404,   -408,  252,  196,
204
  -176,  -556,  792,   268,   32,    372,   40,    96,    -332,  328,  120,
205
  372,   -900,  -40,   472,   -264,  -592,  952,   128,   656,   112,  664,
206
  -232,  420,   4,     -344,  -464,  556,   244,   -416,  -32,   252,  0,
207
  -412,  188,   -696,  508,   -476,  324,   -1096, 656,   -312,  560,  264,
208
  -136,  304,   160,   -64,   -580,  248,   336,   -720,  560,   -348, -288,
209
  -276,  -196,  -500,  852,   -544,  -236,  -1128, -992,  -776,  116,  56,
210
  52,    860,   884,   212,   -12,   168,   1020,  512,   -552,  924,  -148,
211
  716,   188,   164,   -340,  -520,  -184,  880,   -152,  -680,  -208, -1156,
212
  -300,  -528,  -472,  364,   100,   -744,  -1056, -32,   540,   280,  144,
213
  -676,  -32,   -232,  -280,  -224,  96,    568,   -76,   172,   148,  148,
214
  104,   32,    -296,  -32,   788,   -80,   32,    -16,   280,   288,  944,
215
  428,   -484
216
};
217
218
static const int gauss_bits = 11;
219
220
static int luma_subblock_size_y = 32;
221
static int luma_subblock_size_x = 32;
222
223
static int chroma_subblock_size_y = 16;
224
static int chroma_subblock_size_x = 16;
225
226
static const int min_luma_legal_range = 16;
227
static const int max_luma_legal_range = 235;
228
229
static const int min_chroma_legal_range = 16;
230
static const int max_chroma_legal_range = 240;
231
232
static int scaling_lut_y[256];
233
static int scaling_lut_cb[256];
234
static int scaling_lut_cr[256];
235
236
static int grain_min;
237
static int grain_max;
238
239
static uint16_t random_register = 0;  // random number generator register
240
241
static void init_arrays(const aom_film_grain_t *params, int luma_stride,
242
                        int chroma_stride, int ***pred_pos_luma_p,
243
                        int ***pred_pos_chroma_p, int **luma_grain_block,
244
                        int **cb_grain_block, int **cr_grain_block,
245
                        int **y_line_buf, int **cb_line_buf, int **cr_line_buf,
246
                        int **y_col_buf, int **cb_col_buf, int **cr_col_buf,
247
                        int luma_grain_samples, int chroma_grain_samples,
248
0
                        int chroma_subsamp_y, int chroma_subsamp_x) {
249
0
  memset(scaling_lut_y, 0, sizeof(*scaling_lut_y) * 256);
250
0
  memset(scaling_lut_cb, 0, sizeof(*scaling_lut_cb) * 256);
251
0
  memset(scaling_lut_cr, 0, sizeof(*scaling_lut_cr) * 256);
252
253
0
  int num_pos_luma = 2 * params->ar_coeff_lag * (params->ar_coeff_lag + 1);
254
0
  int num_pos_chroma = num_pos_luma;
255
0
  if (params->num_y_points > 0) ++num_pos_chroma;
256
257
0
  int **pred_pos_luma;
258
0
  int **pred_pos_chroma;
259
260
0
  pred_pos_luma = (int **)aom_malloc(sizeof(*pred_pos_luma) * num_pos_luma);
261
262
0
  for (int row = 0; row < num_pos_luma; row++) {
263
0
    pred_pos_luma[row] = (int *)aom_malloc(sizeof(**pred_pos_luma) * 3);
264
0
  }
265
266
0
  pred_pos_chroma =
267
0
      (int **)aom_malloc(sizeof(*pred_pos_chroma) * num_pos_chroma);
268
269
0
  for (int row = 0; row < num_pos_chroma; row++) {
270
0
    pred_pos_chroma[row] = (int *)aom_malloc(sizeof(**pred_pos_chroma) * 3);
271
0
  }
272
273
0
  int pos_ar_index = 0;
274
275
0
  for (int row = -params->ar_coeff_lag; row < 0; row++) {
276
0
    for (int col = -params->ar_coeff_lag; col < params->ar_coeff_lag + 1;
277
0
         col++) {
278
0
      pred_pos_luma[pos_ar_index][0] = row;
279
0
      pred_pos_luma[pos_ar_index][1] = col;
280
0
      pred_pos_luma[pos_ar_index][2] = 0;
281
282
0
      pred_pos_chroma[pos_ar_index][0] = row;
283
0
      pred_pos_chroma[pos_ar_index][1] = col;
284
0
      pred_pos_chroma[pos_ar_index][2] = 0;
285
0
      ++pos_ar_index;
286
0
    }
287
0
  }
288
289
0
  for (int col = -params->ar_coeff_lag; col < 0; col++) {
290
0
    pred_pos_luma[pos_ar_index][0] = 0;
291
0
    pred_pos_luma[pos_ar_index][1] = col;
292
0
    pred_pos_luma[pos_ar_index][2] = 0;
293
294
0
    pred_pos_chroma[pos_ar_index][0] = 0;
295
0
    pred_pos_chroma[pos_ar_index][1] = col;
296
0
    pred_pos_chroma[pos_ar_index][2] = 0;
297
298
0
    ++pos_ar_index;
299
0
  }
300
301
0
  if (params->num_y_points > 0) {
302
0
    pred_pos_chroma[pos_ar_index][0] = 0;
303
0
    pred_pos_chroma[pos_ar_index][1] = 0;
304
0
    pred_pos_chroma[pos_ar_index][2] = 1;
305
0
  }
306
307
0
  *pred_pos_luma_p = pred_pos_luma;
308
0
  *pred_pos_chroma_p = pred_pos_chroma;
309
310
0
  *y_line_buf = (int *)aom_malloc(sizeof(**y_line_buf) * luma_stride * 2);
311
0
  *cb_line_buf = (int *)aom_malloc(sizeof(**cb_line_buf) * chroma_stride *
312
0
                                   (2 >> chroma_subsamp_y));
313
0
  *cr_line_buf = (int *)aom_malloc(sizeof(**cr_line_buf) * chroma_stride *
314
0
                                   (2 >> chroma_subsamp_y));
315
316
0
  *y_col_buf =
317
0
      (int *)aom_malloc(sizeof(**y_col_buf) * (luma_subblock_size_y + 2) * 2);
318
0
  *cb_col_buf =
319
0
      (int *)aom_malloc(sizeof(**cb_col_buf) *
320
0
                        (chroma_subblock_size_y + (2 >> chroma_subsamp_y)) *
321
0
                        (2 >> chroma_subsamp_x));
322
0
  *cr_col_buf =
323
0
      (int *)aom_malloc(sizeof(**cr_col_buf) *
324
0
                        (chroma_subblock_size_y + (2 >> chroma_subsamp_y)) *
325
0
                        (2 >> chroma_subsamp_x));
326
327
0
  *luma_grain_block =
328
0
      (int *)aom_malloc(sizeof(**luma_grain_block) * luma_grain_samples);
329
0
  *cb_grain_block =
330
0
      (int *)aom_malloc(sizeof(**cb_grain_block) * chroma_grain_samples);
331
0
  *cr_grain_block =
332
0
      (int *)aom_malloc(sizeof(**cr_grain_block) * chroma_grain_samples);
333
0
}
334
335
static void dealloc_arrays(const aom_film_grain_t *params, int ***pred_pos_luma,
336
                           int ***pred_pos_chroma, int **luma_grain_block,
337
                           int **cb_grain_block, int **cr_grain_block,
338
                           int **y_line_buf, int **cb_line_buf,
339
                           int **cr_line_buf, int **y_col_buf, int **cb_col_buf,
340
0
                           int **cr_col_buf) {
341
0
  int num_pos_luma = 2 * params->ar_coeff_lag * (params->ar_coeff_lag + 1);
342
0
  int num_pos_chroma = num_pos_luma;
343
0
  if (params->num_y_points > 0) ++num_pos_chroma;
344
345
0
  for (int row = 0; row < num_pos_luma; row++) {
346
0
    aom_free((*pred_pos_luma)[row]);
347
0
  }
348
0
  aom_free(*pred_pos_luma);
349
350
0
  for (int row = 0; row < num_pos_chroma; row++) {
351
0
    aom_free((*pred_pos_chroma)[row]);
352
0
  }
353
0
  aom_free((*pred_pos_chroma));
354
355
0
  aom_free(*y_line_buf);
356
357
0
  aom_free(*cb_line_buf);
358
359
0
  aom_free(*cr_line_buf);
360
361
0
  aom_free(*y_col_buf);
362
363
0
  aom_free(*cb_col_buf);
364
365
0
  aom_free(*cr_col_buf);
366
367
0
  aom_free(*luma_grain_block);
368
369
0
  aom_free(*cb_grain_block);
370
371
0
  aom_free(*cr_grain_block);
372
0
}
373
374
// get a number between 0 and 2^bits - 1
375
0
static INLINE int get_random_number(int bits) {
376
0
  uint16_t bit;
377
0
  bit = ((random_register >> 0) ^ (random_register >> 1) ^
378
0
         (random_register >> 3) ^ (random_register >> 12)) &
379
0
        1;
380
0
  random_register = (random_register >> 1) | (bit << 15);
381
0
  return (random_register >> (16 - bits)) & ((1 << bits) - 1);
382
0
}
383
384
0
static void init_random_generator(int luma_line, uint16_t seed) {
385
  // same for the picture
386
387
0
  uint16_t msb = (seed >> 8) & 255;
388
0
  uint16_t lsb = seed & 255;
389
390
0
  random_register = (msb << 8) + lsb;
391
392
  //  changes for each row
393
0
  int luma_num = luma_line >> 5;
394
395
0
  random_register ^= ((luma_num * 37 + 178) & 255) << 8;
396
0
  random_register ^= ((luma_num * 173 + 105) & 255);
397
0
}
398
399
// Return 0 for success, -1 for failure
400
static int generate_luma_grain_block(
401
    const aom_film_grain_t *params, int **pred_pos_luma, int *luma_grain_block,
402
    int luma_block_size_y, int luma_block_size_x, int luma_grain_stride,
403
0
    int left_pad, int top_pad, int right_pad, int bottom_pad) {
404
0
  if (params->num_y_points == 0) {
405
0
    memset(luma_grain_block, 0,
406
0
           sizeof(*luma_grain_block) * luma_block_size_y * luma_grain_stride);
407
0
    return 0;
408
0
  }
409
410
0
  int bit_depth = params->bit_depth;
411
0
  int gauss_sec_shift = 12 - bit_depth + params->grain_scale_shift;
412
413
0
  int num_pos_luma = 2 * params->ar_coeff_lag * (params->ar_coeff_lag + 1);
414
0
  int rounding_offset = (1 << (params->ar_coeff_shift - 1));
415
416
0
  for (int i = 0; i < luma_block_size_y; i++)
417
0
    for (int j = 0; j < luma_block_size_x; j++)
418
0
      luma_grain_block[i * luma_grain_stride + j] =
419
0
          (gaussian_sequence[get_random_number(gauss_bits)] +
420
0
           ((1 << gauss_sec_shift) >> 1)) >>
421
0
          gauss_sec_shift;
422
423
0
  for (int i = top_pad; i < luma_block_size_y - bottom_pad; i++)
424
0
    for (int j = left_pad; j < luma_block_size_x - right_pad; j++) {
425
0
      int wsum = 0;
426
0
      for (int pos = 0; pos < num_pos_luma; pos++) {
427
0
        wsum = wsum + params->ar_coeffs_y[pos] *
428
0
                          luma_grain_block[(i + pred_pos_luma[pos][0]) *
429
0
                                               luma_grain_stride +
430
0
                                           j + pred_pos_luma[pos][1]];
431
0
      }
432
0
      luma_grain_block[i * luma_grain_stride + j] =
433
0
          clamp(luma_grain_block[i * luma_grain_stride + j] +
434
0
                    ((wsum + rounding_offset) >> params->ar_coeff_shift),
435
0
                grain_min, grain_max);
436
0
    }
437
0
  return 0;
438
0
}
439
440
// Return 0 for success, -1 for failure
441
static int generate_chroma_grain_blocks(
442
    const aom_film_grain_t *params,
443
    //                                  int** pred_pos_luma,
444
    int **pred_pos_chroma, int *luma_grain_block, int *cb_grain_block,
445
    int *cr_grain_block, int luma_grain_stride, int chroma_block_size_y,
446
    int chroma_block_size_x, int chroma_grain_stride, int left_pad, int top_pad,
447
0
    int right_pad, int bottom_pad, int chroma_subsamp_y, int chroma_subsamp_x) {
448
0
  int bit_depth = params->bit_depth;
449
0
  int gauss_sec_shift = 12 - bit_depth + params->grain_scale_shift;
450
451
0
  int num_pos_chroma = 2 * params->ar_coeff_lag * (params->ar_coeff_lag + 1);
452
0
  if (params->num_y_points > 0) ++num_pos_chroma;
453
0
  int rounding_offset = (1 << (params->ar_coeff_shift - 1));
454
0
  int chroma_grain_block_size = chroma_block_size_y * chroma_grain_stride;
455
456
0
  if (params->num_cb_points || params->chroma_scaling_from_luma) {
457
0
    init_random_generator(7 << 5, params->random_seed);
458
459
0
    for (int i = 0; i < chroma_block_size_y; i++)
460
0
      for (int j = 0; j < chroma_block_size_x; j++)
461
0
        cb_grain_block[i * chroma_grain_stride + j] =
462
0
            (gaussian_sequence[get_random_number(gauss_bits)] +
463
0
             ((1 << gauss_sec_shift) >> 1)) >>
464
0
            gauss_sec_shift;
465
0
  } else {
466
0
    memset(cb_grain_block, 0,
467
0
           sizeof(*cb_grain_block) * chroma_grain_block_size);
468
0
  }
469
470
0
  if (params->num_cr_points || params->chroma_scaling_from_luma) {
471
0
    init_random_generator(11 << 5, params->random_seed);
472
473
0
    for (int i = 0; i < chroma_block_size_y; i++)
474
0
      for (int j = 0; j < chroma_block_size_x; j++)
475
0
        cr_grain_block[i * chroma_grain_stride + j] =
476
0
            (gaussian_sequence[get_random_number(gauss_bits)] +
477
0
             ((1 << gauss_sec_shift) >> 1)) >>
478
0
            gauss_sec_shift;
479
0
  } else {
480
0
    memset(cr_grain_block, 0,
481
0
           sizeof(*cr_grain_block) * chroma_grain_block_size);
482
0
  }
483
484
0
  for (int i = top_pad; i < chroma_block_size_y - bottom_pad; i++)
485
0
    for (int j = left_pad; j < chroma_block_size_x - right_pad; j++) {
486
0
      int wsum_cb = 0;
487
0
      int wsum_cr = 0;
488
0
      for (int pos = 0; pos < num_pos_chroma; pos++) {
489
0
        if (pred_pos_chroma[pos][2] == 0) {
490
0
          wsum_cb = wsum_cb + params->ar_coeffs_cb[pos] *
491
0
                                  cb_grain_block[(i + pred_pos_chroma[pos][0]) *
492
0
                                                     chroma_grain_stride +
493
0
                                                 j + pred_pos_chroma[pos][1]];
494
0
          wsum_cr = wsum_cr + params->ar_coeffs_cr[pos] *
495
0
                                  cr_grain_block[(i + pred_pos_chroma[pos][0]) *
496
0
                                                     chroma_grain_stride +
497
0
                                                 j + pred_pos_chroma[pos][1]];
498
0
        } else if (pred_pos_chroma[pos][2] == 1) {
499
0
          int av_luma = 0;
500
0
          int luma_coord_y = ((i - top_pad) << chroma_subsamp_y) + top_pad;
501
0
          int luma_coord_x = ((j - left_pad) << chroma_subsamp_x) + left_pad;
502
503
0
          for (int k = luma_coord_y; k < luma_coord_y + chroma_subsamp_y + 1;
504
0
               k++)
505
0
            for (int l = luma_coord_x; l < luma_coord_x + chroma_subsamp_x + 1;
506
0
                 l++)
507
0
              av_luma += luma_grain_block[k * luma_grain_stride + l];
508
509
0
          av_luma =
510
0
              (av_luma + ((1 << (chroma_subsamp_y + chroma_subsamp_x)) >> 1)) >>
511
0
              (chroma_subsamp_y + chroma_subsamp_x);
512
513
0
          wsum_cb = wsum_cb + params->ar_coeffs_cb[pos] * av_luma;
514
0
          wsum_cr = wsum_cr + params->ar_coeffs_cr[pos] * av_luma;
515
0
        } else {
516
0
          fprintf(
517
0
              stderr,
518
0
              "Grain synthesis: prediction between two chroma components is "
519
0
              "not supported!");
520
0
          return -1;
521
0
        }
522
0
      }
523
0
      if (params->num_cb_points || params->chroma_scaling_from_luma)
524
0
        cb_grain_block[i * chroma_grain_stride + j] =
525
0
            clamp(cb_grain_block[i * chroma_grain_stride + j] +
526
0
                      ((wsum_cb + rounding_offset) >> params->ar_coeff_shift),
527
0
                  grain_min, grain_max);
528
0
      if (params->num_cr_points || params->chroma_scaling_from_luma)
529
0
        cr_grain_block[i * chroma_grain_stride + j] =
530
0
            clamp(cr_grain_block[i * chroma_grain_stride + j] +
531
0
                      ((wsum_cr + rounding_offset) >> params->ar_coeff_shift),
532
0
                  grain_min, grain_max);
533
0
    }
534
0
  return 0;
535
0
}
536
537
static void init_scaling_function(const int scaling_points[][2], int num_points,
538
0
                                  int scaling_lut[]) {
539
0
  if (num_points == 0) return;
540
541
0
  for (int i = 0; i < scaling_points[0][0]; i++)
542
0
    scaling_lut[i] = scaling_points[0][1];
543
544
0
  for (int point = 0; point < num_points - 1; point++) {
545
0
    int delta_y = scaling_points[point + 1][1] - scaling_points[point][1];
546
0
    int delta_x = scaling_points[point + 1][0] - scaling_points[point][0];
547
548
0
    int64_t delta = delta_y * ((65536 + (delta_x >> 1)) / delta_x);
549
550
0
    for (int x = 0; x < delta_x; x++) {
551
0
      scaling_lut[scaling_points[point][0] + x] =
552
0
          scaling_points[point][1] + (int)((x * delta + 32768) >> 16);
553
0
    }
554
0
  }
555
556
0
  for (int i = scaling_points[num_points - 1][0]; i < 256; i++)
557
0
    scaling_lut[i] = scaling_points[num_points - 1][1];
558
0
}
559
560
// function that extracts samples from a LUT (and interpolates intemediate
561
// frames for 10- and 12-bit video)
562
0
static int scale_LUT(int *scaling_lut, int index, int bit_depth) {
563
0
  int x = index >> (bit_depth - 8);
564
565
0
  if (!(bit_depth - 8) || x == 255)
566
0
    return scaling_lut[x];
567
0
  else
568
0
    return scaling_lut[x] + (((scaling_lut[x + 1] - scaling_lut[x]) *
569
0
                                  (index & ((1 << (bit_depth - 8)) - 1)) +
570
0
                              (1 << (bit_depth - 9))) >>
571
0
                             (bit_depth - 8));
572
0
}
573
574
static void add_noise_to_block(const aom_film_grain_t *params, uint8_t *luma,
575
                               uint8_t *cb, uint8_t *cr, int luma_stride,
576
                               int chroma_stride, int *luma_grain,
577
                               int *cb_grain, int *cr_grain,
578
                               int luma_grain_stride, int chroma_grain_stride,
579
                               int half_luma_height, int half_luma_width,
580
                               int bit_depth, int chroma_subsamp_y,
581
0
                               int chroma_subsamp_x, int mc_identity) {
582
0
  int cb_mult = params->cb_mult - 128;            // fixed scale
583
0
  int cb_luma_mult = params->cb_luma_mult - 128;  // fixed scale
584
0
  int cb_offset = params->cb_offset - 256;
585
586
0
  int cr_mult = params->cr_mult - 128;            // fixed scale
587
0
  int cr_luma_mult = params->cr_luma_mult - 128;  // fixed scale
588
0
  int cr_offset = params->cr_offset - 256;
589
590
0
  int rounding_offset = (1 << (params->scaling_shift - 1));
591
592
0
  int apply_y = params->num_y_points > 0 ? 1 : 0;
593
0
  int apply_cb =
594
0
      (params->num_cb_points > 0 || params->chroma_scaling_from_luma) ? 1 : 0;
595
0
  int apply_cr =
596
0
      (params->num_cr_points > 0 || params->chroma_scaling_from_luma) ? 1 : 0;
597
598
0
  if (params->chroma_scaling_from_luma) {
599
0
    cb_mult = 0;        // fixed scale
600
0
    cb_luma_mult = 64;  // fixed scale
601
0
    cb_offset = 0;
602
603
0
    cr_mult = 0;        // fixed scale
604
0
    cr_luma_mult = 64;  // fixed scale
605
0
    cr_offset = 0;
606
0
  }
607
608
0
  int min_luma, max_luma, min_chroma, max_chroma;
609
610
0
  if (params->clip_to_restricted_range) {
611
0
    min_luma = min_luma_legal_range;
612
0
    max_luma = max_luma_legal_range;
613
614
0
    if (mc_identity) {
615
0
      min_chroma = min_luma_legal_range;
616
0
      max_chroma = max_luma_legal_range;
617
0
    } else {
618
0
      min_chroma = min_chroma_legal_range;
619
0
      max_chroma = max_chroma_legal_range;
620
0
    }
621
0
  } else {
622
0
    min_luma = min_chroma = 0;
623
0
    max_luma = max_chroma = 255;
624
0
  }
625
626
0
  for (int i = 0; i < (half_luma_height << (1 - chroma_subsamp_y)); i++) {
627
0
    for (int j = 0; j < (half_luma_width << (1 - chroma_subsamp_x)); j++) {
628
0
      int average_luma = 0;
629
0
      if (chroma_subsamp_x) {
630
0
        average_luma = (luma[(i << chroma_subsamp_y) * luma_stride +
631
0
                             (j << chroma_subsamp_x)] +
632
0
                        luma[(i << chroma_subsamp_y) * luma_stride +
633
0
                             (j << chroma_subsamp_x) + 1] +
634
0
                        1) >>
635
0
                       1;
636
0
      } else {
637
0
        average_luma = luma[(i << chroma_subsamp_y) * luma_stride + j];
638
0
      }
639
640
0
      if (apply_cb) {
641
0
        cb[i * chroma_stride + j] = clamp(
642
0
            cb[i * chroma_stride + j] +
643
0
                ((scale_LUT(scaling_lut_cb,
644
0
                            clamp(((average_luma * cb_luma_mult +
645
0
                                    cb_mult * cb[i * chroma_stride + j]) >>
646
0
                                   6) +
647
0
                                      cb_offset,
648
0
                                  0, (256 << (bit_depth - 8)) - 1),
649
0
                            8) *
650
0
                      cb_grain[i * chroma_grain_stride + j] +
651
0
                  rounding_offset) >>
652
0
                 params->scaling_shift),
653
0
            min_chroma, max_chroma);
654
0
      }
655
656
0
      if (apply_cr) {
657
0
        cr[i * chroma_stride + j] = clamp(
658
0
            cr[i * chroma_stride + j] +
659
0
                ((scale_LUT(scaling_lut_cr,
660
0
                            clamp(((average_luma * cr_luma_mult +
661
0
                                    cr_mult * cr[i * chroma_stride + j]) >>
662
0
                                   6) +
663
0
                                      cr_offset,
664
0
                                  0, (256 << (bit_depth - 8)) - 1),
665
0
                            8) *
666
0
                      cr_grain[i * chroma_grain_stride + j] +
667
0
                  rounding_offset) >>
668
0
                 params->scaling_shift),
669
0
            min_chroma, max_chroma);
670
0
      }
671
0
    }
672
0
  }
673
674
0
  if (apply_y) {
675
0
    for (int i = 0; i < (half_luma_height << 1); i++) {
676
0
      for (int j = 0; j < (half_luma_width << 1); j++) {
677
0
        luma[i * luma_stride + j] =
678
0
            clamp(luma[i * luma_stride + j] +
679
0
                      ((scale_LUT(scaling_lut_y, luma[i * luma_stride + j], 8) *
680
0
                            luma_grain[i * luma_grain_stride + j] +
681
0
                        rounding_offset) >>
682
0
                       params->scaling_shift),
683
0
                  min_luma, max_luma);
684
0
      }
685
0
    }
686
0
  }
687
0
}
688
689
static void add_noise_to_block_hbd(
690
    const aom_film_grain_t *params, uint16_t *luma, uint16_t *cb, uint16_t *cr,
691
    int luma_stride, int chroma_stride, int *luma_grain, int *cb_grain,
692
    int *cr_grain, int luma_grain_stride, int chroma_grain_stride,
693
    int half_luma_height, int half_luma_width, int bit_depth,
694
0
    int chroma_subsamp_y, int chroma_subsamp_x, int mc_identity) {
695
0
  int cb_mult = params->cb_mult - 128;            // fixed scale
696
0
  int cb_luma_mult = params->cb_luma_mult - 128;  // fixed scale
697
  // offset value depends on the bit depth
698
0
  int cb_offset = (params->cb_offset << (bit_depth - 8)) - (1 << bit_depth);
699
700
0
  int cr_mult = params->cr_mult - 128;            // fixed scale
701
0
  int cr_luma_mult = params->cr_luma_mult - 128;  // fixed scale
702
  // offset value depends on the bit depth
703
0
  int cr_offset = (params->cr_offset << (bit_depth - 8)) - (1 << bit_depth);
704
705
0
  int rounding_offset = (1 << (params->scaling_shift - 1));
706
707
0
  int apply_y = params->num_y_points > 0 ? 1 : 0;
708
0
  int apply_cb =
709
0
      (params->num_cb_points > 0 || params->chroma_scaling_from_luma) > 0 ? 1
710
0
                                                                          : 0;
711
0
  int apply_cr =
712
0
      (params->num_cr_points > 0 || params->chroma_scaling_from_luma) > 0 ? 1
713
0
                                                                          : 0;
714
715
0
  if (params->chroma_scaling_from_luma) {
716
0
    cb_mult = 0;        // fixed scale
717
0
    cb_luma_mult = 64;  // fixed scale
718
0
    cb_offset = 0;
719
720
0
    cr_mult = 0;        // fixed scale
721
0
    cr_luma_mult = 64;  // fixed scale
722
0
    cr_offset = 0;
723
0
  }
724
725
0
  int min_luma, max_luma, min_chroma, max_chroma;
726
727
0
  if (params->clip_to_restricted_range) {
728
0
    min_luma = min_luma_legal_range << (bit_depth - 8);
729
0
    max_luma = max_luma_legal_range << (bit_depth - 8);
730
731
0
    if (mc_identity) {
732
0
      min_chroma = min_luma_legal_range << (bit_depth - 8);
733
0
      max_chroma = max_luma_legal_range << (bit_depth - 8);
734
0
    } else {
735
0
      min_chroma = min_chroma_legal_range << (bit_depth - 8);
736
0
      max_chroma = max_chroma_legal_range << (bit_depth - 8);
737
0
    }
738
0
  } else {
739
0
    min_luma = min_chroma = 0;
740
0
    max_luma = max_chroma = (256 << (bit_depth - 8)) - 1;
741
0
  }
742
743
0
  for (int i = 0; i < (half_luma_height << (1 - chroma_subsamp_y)); i++) {
744
0
    for (int j = 0; j < (half_luma_width << (1 - chroma_subsamp_x)); j++) {
745
0
      int average_luma = 0;
746
0
      if (chroma_subsamp_x) {
747
0
        average_luma = (luma[(i << chroma_subsamp_y) * luma_stride +
748
0
                             (j << chroma_subsamp_x)] +
749
0
                        luma[(i << chroma_subsamp_y) * luma_stride +
750
0
                             (j << chroma_subsamp_x) + 1] +
751
0
                        1) >>
752
0
                       1;
753
0
      } else {
754
0
        average_luma = luma[(i << chroma_subsamp_y) * luma_stride + j];
755
0
      }
756
757
0
      if (apply_cb) {
758
0
        cb[i * chroma_stride + j] = clamp(
759
0
            cb[i * chroma_stride + j] +
760
0
                ((scale_LUT(scaling_lut_cb,
761
0
                            clamp(((average_luma * cb_luma_mult +
762
0
                                    cb_mult * cb[i * chroma_stride + j]) >>
763
0
                                   6) +
764
0
                                      cb_offset,
765
0
                                  0, (256 << (bit_depth - 8)) - 1),
766
0
                            bit_depth) *
767
0
                      cb_grain[i * chroma_grain_stride + j] +
768
0
                  rounding_offset) >>
769
0
                 params->scaling_shift),
770
0
            min_chroma, max_chroma);
771
0
      }
772
0
      if (apply_cr) {
773
0
        cr[i * chroma_stride + j] = clamp(
774
0
            cr[i * chroma_stride + j] +
775
0
                ((scale_LUT(scaling_lut_cr,
776
0
                            clamp(((average_luma * cr_luma_mult +
777
0
                                    cr_mult * cr[i * chroma_stride + j]) >>
778
0
                                   6) +
779
0
                                      cr_offset,
780
0
                                  0, (256 << (bit_depth - 8)) - 1),
781
0
                            bit_depth) *
782
0
                      cr_grain[i * chroma_grain_stride + j] +
783
0
                  rounding_offset) >>
784
0
                 params->scaling_shift),
785
0
            min_chroma, max_chroma);
786
0
      }
787
0
    }
788
0
  }
789
790
0
  if (apply_y) {
791
0
    for (int i = 0; i < (half_luma_height << 1); i++) {
792
0
      for (int j = 0; j < (half_luma_width << 1); j++) {
793
0
        luma[i * luma_stride + j] =
794
0
            clamp(luma[i * luma_stride + j] +
795
0
                      ((scale_LUT(scaling_lut_y, luma[i * luma_stride + j],
796
0
                                  bit_depth) *
797
0
                            luma_grain[i * luma_grain_stride + j] +
798
0
                        rounding_offset) >>
799
0
                       params->scaling_shift),
800
0
                  min_luma, max_luma);
801
0
      }
802
0
    }
803
0
  }
804
0
}
805
806
static void copy_rect(uint8_t *src, int src_stride, uint8_t *dst,
807
                      int dst_stride, int width, int height,
808
0
                      int use_high_bit_depth) {
809
0
  int hbd_coeff = use_high_bit_depth ? 2 : 1;
810
0
  while (height) {
811
0
    memcpy(dst, src, width * sizeof(uint8_t) * hbd_coeff);
812
0
    src += src_stride;
813
0
    dst += dst_stride;
814
0
    --height;
815
0
  }
816
0
  return;
817
0
}
818
819
static void copy_area(int *src, int src_stride, int *dst, int dst_stride,
820
0
                      int width, int height) {
821
0
  while (height) {
822
0
    memcpy(dst, src, width * sizeof(*src));
823
0
    src += src_stride;
824
0
    dst += dst_stride;
825
0
    --height;
826
0
  }
827
0
  return;
828
0
}
829
830
static void extend_even(uint8_t *dst, int dst_stride, int width, int height,
831
0
                        int use_high_bit_depth) {
832
0
  if ((width & 1) == 0 && (height & 1) == 0) return;
833
0
  if (use_high_bit_depth) {
834
0
    uint16_t *dst16 = (uint16_t *)dst;
835
0
    int dst16_stride = dst_stride / 2;
836
0
    if (width & 1) {
837
0
      for (int i = 0; i < height; ++i)
838
0
        dst16[i * dst16_stride + width] = dst16[i * dst16_stride + width - 1];
839
0
    }
840
0
    width = (width + 1) & (~1);
841
0
    if (height & 1) {
842
0
      memcpy(&dst16[height * dst16_stride], &dst16[(height - 1) * dst16_stride],
843
0
             sizeof(*dst16) * width);
844
0
    }
845
0
  } else {
846
0
    if (width & 1) {
847
0
      for (int i = 0; i < height; ++i)
848
0
        dst[i * dst_stride + width] = dst[i * dst_stride + width - 1];
849
0
    }
850
0
    width = (width + 1) & (~1);
851
0
    if (height & 1) {
852
0
      memcpy(&dst[height * dst_stride], &dst[(height - 1) * dst_stride],
853
0
             sizeof(*dst) * width);
854
0
    }
855
0
  }
856
0
}
857
858
static void ver_boundary_overlap(int *left_block, int left_stride,
859
                                 int *right_block, int right_stride,
860
                                 int *dst_block, int dst_stride, int width,
861
0
                                 int height) {
862
0
  if (width == 1) {
863
0
    while (height) {
864
0
      *dst_block = clamp((*left_block * 23 + *right_block * 22 + 16) >> 5,
865
0
                         grain_min, grain_max);
866
0
      left_block += left_stride;
867
0
      right_block += right_stride;
868
0
      dst_block += dst_stride;
869
0
      --height;
870
0
    }
871
0
    return;
872
0
  } else if (width == 2) {
873
0
    while (height) {
874
0
      dst_block[0] = clamp((27 * left_block[0] + 17 * right_block[0] + 16) >> 5,
875
0
                           grain_min, grain_max);
876
0
      dst_block[1] = clamp((17 * left_block[1] + 27 * right_block[1] + 16) >> 5,
877
0
                           grain_min, grain_max);
878
0
      left_block += left_stride;
879
0
      right_block += right_stride;
880
0
      dst_block += dst_stride;
881
0
      --height;
882
0
    }
883
0
    return;
884
0
  }
885
0
}
886
887
static void hor_boundary_overlap(int *top_block, int top_stride,
888
                                 int *bottom_block, int bottom_stride,
889
                                 int *dst_block, int dst_stride, int width,
890
0
                                 int height) {
891
0
  if (height == 1) {
892
0
    while (width) {
893
0
      *dst_block = clamp((*top_block * 23 + *bottom_block * 22 + 16) >> 5,
894
0
                         grain_min, grain_max);
895
0
      ++top_block;
896
0
      ++bottom_block;
897
0
      ++dst_block;
898
0
      --width;
899
0
    }
900
0
    return;
901
0
  } else if (height == 2) {
902
0
    while (width) {
903
0
      dst_block[0] = clamp((27 * top_block[0] + 17 * bottom_block[0] + 16) >> 5,
904
0
                           grain_min, grain_max);
905
0
      dst_block[dst_stride] = clamp((17 * top_block[top_stride] +
906
0
                                     27 * bottom_block[bottom_stride] + 16) >>
907
0
                                        5,
908
0
                                    grain_min, grain_max);
909
0
      ++top_block;
910
0
      ++bottom_block;
911
0
      ++dst_block;
912
0
      --width;
913
0
    }
914
0
    return;
915
0
  }
916
0
}
917
918
int av1_add_film_grain(const aom_film_grain_t *params, const aom_image_t *src,
919
0
                       aom_image_t *dst) {
920
0
  uint8_t *luma, *cb, *cr;
921
0
  int height, width, luma_stride, chroma_stride;
922
0
  int use_high_bit_depth = 0;
923
0
  int chroma_subsamp_x = 0;
924
0
  int chroma_subsamp_y = 0;
925
0
  int mc_identity = src->mc == AOM_CICP_MC_IDENTITY ? 1 : 0;
926
927
0
  switch (src->fmt) {
928
0
    case AOM_IMG_FMT_AOMI420:
929
0
    case AOM_IMG_FMT_I420:
930
0
      use_high_bit_depth = 0;
931
0
      chroma_subsamp_x = 1;
932
0
      chroma_subsamp_y = 1;
933
0
      break;
934
0
    case AOM_IMG_FMT_I42016:
935
0
      use_high_bit_depth = 1;
936
0
      chroma_subsamp_x = 1;
937
0
      chroma_subsamp_y = 1;
938
0
      break;
939
      //    case AOM_IMG_FMT_444A:
940
0
    case AOM_IMG_FMT_I444:
941
0
      use_high_bit_depth = 0;
942
0
      chroma_subsamp_x = 0;
943
0
      chroma_subsamp_y = 0;
944
0
      break;
945
0
    case AOM_IMG_FMT_I44416:
946
0
      use_high_bit_depth = 1;
947
0
      chroma_subsamp_x = 0;
948
0
      chroma_subsamp_y = 0;
949
0
      break;
950
0
    case AOM_IMG_FMT_I422:
951
0
      use_high_bit_depth = 0;
952
0
      chroma_subsamp_x = 1;
953
0
      chroma_subsamp_y = 0;
954
0
      break;
955
0
    case AOM_IMG_FMT_I42216:
956
0
      use_high_bit_depth = 1;
957
0
      chroma_subsamp_x = 1;
958
0
      chroma_subsamp_y = 0;
959
0
      break;
960
0
    default:  // unknown input format
961
0
      fprintf(stderr, "Film grain error: input format is not supported!");
962
0
      return -1;
963
0
  }
964
965
0
  assert(params->bit_depth == src->bit_depth);
966
967
0
  dst->fmt = src->fmt;
968
0
  dst->bit_depth = src->bit_depth;
969
970
0
  dst->r_w = src->r_w;
971
0
  dst->r_h = src->r_h;
972
0
  dst->d_w = src->d_w;
973
0
  dst->d_h = src->d_h;
974
975
0
  dst->cp = src->cp;
976
0
  dst->tc = src->tc;
977
0
  dst->mc = src->mc;
978
979
0
  dst->monochrome = src->monochrome;
980
0
  dst->csp = src->csp;
981
0
  dst->range = src->range;
982
983
0
  dst->x_chroma_shift = src->x_chroma_shift;
984
0
  dst->y_chroma_shift = src->y_chroma_shift;
985
986
0
  dst->temporal_id = src->temporal_id;
987
0
  dst->spatial_id = src->spatial_id;
988
989
0
  width = src->d_w % 2 ? src->d_w + 1 : src->d_w;
990
0
  height = src->d_h % 2 ? src->d_h + 1 : src->d_h;
991
992
0
  copy_rect(src->planes[AOM_PLANE_Y], src->stride[AOM_PLANE_Y],
993
0
            dst->planes[AOM_PLANE_Y], dst->stride[AOM_PLANE_Y], src->d_w,
994
0
            src->d_h, use_high_bit_depth);
995
  // Note that dst is already assumed to be aligned to even.
996
0
  extend_even(dst->planes[AOM_PLANE_Y], dst->stride[AOM_PLANE_Y], src->d_w,
997
0
              src->d_h, use_high_bit_depth);
998
999
0
  if (!src->monochrome) {
1000
0
    copy_rect(src->planes[AOM_PLANE_U], src->stride[AOM_PLANE_U],
1001
0
              dst->planes[AOM_PLANE_U], dst->stride[AOM_PLANE_U],
1002
0
              width >> chroma_subsamp_x, height >> chroma_subsamp_y,
1003
0
              use_high_bit_depth);
1004
1005
0
    copy_rect(src->planes[AOM_PLANE_V], src->stride[AOM_PLANE_V],
1006
0
              dst->planes[AOM_PLANE_V], dst->stride[AOM_PLANE_V],
1007
0
              width >> chroma_subsamp_x, height >> chroma_subsamp_y,
1008
0
              use_high_bit_depth);
1009
0
  }
1010
1011
0
  luma = dst->planes[AOM_PLANE_Y];
1012
0
  cb = dst->planes[AOM_PLANE_U];
1013
0
  cr = dst->planes[AOM_PLANE_V];
1014
1015
  // luma and chroma strides in samples
1016
0
  luma_stride = dst->stride[AOM_PLANE_Y] >> use_high_bit_depth;
1017
0
  chroma_stride = dst->stride[AOM_PLANE_U] >> use_high_bit_depth;
1018
1019
0
  return av1_add_film_grain_run(
1020
0
      params, luma, cb, cr, height, width, luma_stride, chroma_stride,
1021
0
      use_high_bit_depth, chroma_subsamp_y, chroma_subsamp_x, mc_identity);
1022
0
}
1023
1024
int av1_add_film_grain_run(const aom_film_grain_t *params, uint8_t *luma,
1025
                           uint8_t *cb, uint8_t *cr, int height, int width,
1026
                           int luma_stride, int chroma_stride,
1027
                           int use_high_bit_depth, int chroma_subsamp_y,
1028
0
                           int chroma_subsamp_x, int mc_identity) {
1029
0
  int **pred_pos_luma;
1030
0
  int **pred_pos_chroma;
1031
0
  int *luma_grain_block;
1032
0
  int *cb_grain_block;
1033
0
  int *cr_grain_block;
1034
1035
0
  int *y_line_buf;
1036
0
  int *cb_line_buf;
1037
0
  int *cr_line_buf;
1038
1039
0
  int *y_col_buf;
1040
0
  int *cb_col_buf;
1041
0
  int *cr_col_buf;
1042
1043
0
  random_register = params->random_seed;
1044
1045
0
  int left_pad = 3;
1046
0
  int right_pad = 3;  // padding to offset for AR coefficients
1047
0
  int top_pad = 3;
1048
0
  int bottom_pad = 0;
1049
1050
0
  int ar_padding = 3;  // maximum lag used for stabilization of AR coefficients
1051
1052
0
  luma_subblock_size_y = 32;
1053
0
  luma_subblock_size_x = 32;
1054
1055
0
  chroma_subblock_size_y = luma_subblock_size_y >> chroma_subsamp_y;
1056
0
  chroma_subblock_size_x = luma_subblock_size_x >> chroma_subsamp_x;
1057
1058
  // Initial padding is only needed for generation of
1059
  // film grain templates (to stabilize the AR process)
1060
  // Only a 64x64 luma and 32x32 chroma part of a template
1061
  // is used later for adding grain, padding can be discarded
1062
1063
0
  int luma_block_size_y =
1064
0
      top_pad + 2 * ar_padding + luma_subblock_size_y * 2 + bottom_pad;
1065
0
  int luma_block_size_x = left_pad + 2 * ar_padding + luma_subblock_size_x * 2 +
1066
0
                          2 * ar_padding + right_pad;
1067
1068
0
  int chroma_block_size_y = top_pad + (2 >> chroma_subsamp_y) * ar_padding +
1069
0
                            chroma_subblock_size_y * 2 + bottom_pad;
1070
0
  int chroma_block_size_x = left_pad + (2 >> chroma_subsamp_x) * ar_padding +
1071
0
                            chroma_subblock_size_x * 2 +
1072
0
                            (2 >> chroma_subsamp_x) * ar_padding + right_pad;
1073
1074
0
  int luma_grain_stride = luma_block_size_x;
1075
0
  int chroma_grain_stride = chroma_block_size_x;
1076
1077
0
  int overlap = params->overlap_flag;
1078
0
  int bit_depth = params->bit_depth;
1079
1080
0
  const int grain_center = 128 << (bit_depth - 8);
1081
0
  grain_min = 0 - grain_center;
1082
0
  grain_max = grain_center - 1;
1083
1084
0
  init_arrays(params, luma_stride, chroma_stride, &pred_pos_luma,
1085
0
              &pred_pos_chroma, &luma_grain_block, &cb_grain_block,
1086
0
              &cr_grain_block, &y_line_buf, &cb_line_buf, &cr_line_buf,
1087
0
              &y_col_buf, &cb_col_buf, &cr_col_buf,
1088
0
              luma_block_size_y * luma_block_size_x,
1089
0
              chroma_block_size_y * chroma_block_size_x, chroma_subsamp_y,
1090
0
              chroma_subsamp_x);
1091
1092
0
  if (generate_luma_grain_block(params, pred_pos_luma, luma_grain_block,
1093
0
                                luma_block_size_y, luma_block_size_x,
1094
0
                                luma_grain_stride, left_pad, top_pad, right_pad,
1095
0
                                bottom_pad))
1096
0
    return -1;
1097
1098
0
  if (generate_chroma_grain_blocks(
1099
0
          params,
1100
          //                               pred_pos_luma,
1101
0
          pred_pos_chroma, luma_grain_block, cb_grain_block, cr_grain_block,
1102
0
          luma_grain_stride, chroma_block_size_y, chroma_block_size_x,
1103
0
          chroma_grain_stride, left_pad, top_pad, right_pad, bottom_pad,
1104
0
          chroma_subsamp_y, chroma_subsamp_x))
1105
0
    return -1;
1106
1107
0
  init_scaling_function(params->scaling_points_y, params->num_y_points,
1108
0
                        scaling_lut_y);
1109
1110
0
  if (params->chroma_scaling_from_luma) {
1111
0
    memcpy(scaling_lut_cb, scaling_lut_y, sizeof(*scaling_lut_y) * 256);
1112
0
    memcpy(scaling_lut_cr, scaling_lut_y, sizeof(*scaling_lut_y) * 256);
1113
0
  } else {
1114
0
    init_scaling_function(params->scaling_points_cb, params->num_cb_points,
1115
0
                          scaling_lut_cb);
1116
0
    init_scaling_function(params->scaling_points_cr, params->num_cr_points,
1117
0
                          scaling_lut_cr);
1118
0
  }
1119
0
  for (int y = 0; y < height / 2; y += (luma_subblock_size_y >> 1)) {
1120
0
    init_random_generator(y * 2, params->random_seed);
1121
1122
0
    for (int x = 0; x < width / 2; x += (luma_subblock_size_x >> 1)) {
1123
0
      int offset_y = get_random_number(8);
1124
0
      int offset_x = (offset_y >> 4) & 15;
1125
0
      offset_y &= 15;
1126
1127
0
      int luma_offset_y = left_pad + 2 * ar_padding + (offset_y << 1);
1128
0
      int luma_offset_x = top_pad + 2 * ar_padding + (offset_x << 1);
1129
1130
0
      int chroma_offset_y = top_pad + (2 >> chroma_subsamp_y) * ar_padding +
1131
0
                            offset_y * (2 >> chroma_subsamp_y);
1132
0
      int chroma_offset_x = left_pad + (2 >> chroma_subsamp_x) * ar_padding +
1133
0
                            offset_x * (2 >> chroma_subsamp_x);
1134
1135
0
      if (overlap && x) {
1136
0
        ver_boundary_overlap(
1137
0
            y_col_buf, 2,
1138
0
            luma_grain_block + luma_offset_y * luma_grain_stride +
1139
0
                luma_offset_x,
1140
0
            luma_grain_stride, y_col_buf, 2, 2,
1141
0
            AOMMIN(luma_subblock_size_y + 2, height - (y << 1)));
1142
1143
0
        ver_boundary_overlap(
1144
0
            cb_col_buf, 2 >> chroma_subsamp_x,
1145
0
            cb_grain_block + chroma_offset_y * chroma_grain_stride +
1146
0
                chroma_offset_x,
1147
0
            chroma_grain_stride, cb_col_buf, 2 >> chroma_subsamp_x,
1148
0
            2 >> chroma_subsamp_x,
1149
0
            AOMMIN(chroma_subblock_size_y + (2 >> chroma_subsamp_y),
1150
0
                   (height - (y << 1)) >> chroma_subsamp_y));
1151
1152
0
        ver_boundary_overlap(
1153
0
            cr_col_buf, 2 >> chroma_subsamp_x,
1154
0
            cr_grain_block + chroma_offset_y * chroma_grain_stride +
1155
0
                chroma_offset_x,
1156
0
            chroma_grain_stride, cr_col_buf, 2 >> chroma_subsamp_x,
1157
0
            2 >> chroma_subsamp_x,
1158
0
            AOMMIN(chroma_subblock_size_y + (2 >> chroma_subsamp_y),
1159
0
                   (height - (y << 1)) >> chroma_subsamp_y));
1160
1161
0
        int i = y ? 1 : 0;
1162
1163
0
        if (use_high_bit_depth) {
1164
0
          add_noise_to_block_hbd(
1165
0
              params,
1166
0
              (uint16_t *)luma + ((y + i) << 1) * luma_stride + (x << 1),
1167
0
              (uint16_t *)cb +
1168
0
                  ((y + i) << (1 - chroma_subsamp_y)) * chroma_stride +
1169
0
                  (x << (1 - chroma_subsamp_x)),
1170
0
              (uint16_t *)cr +
1171
0
                  ((y + i) << (1 - chroma_subsamp_y)) * chroma_stride +
1172
0
                  (x << (1 - chroma_subsamp_x)),
1173
0
              luma_stride, chroma_stride, y_col_buf + i * 4,
1174
0
              cb_col_buf + i * (2 - chroma_subsamp_y) * (2 - chroma_subsamp_x),
1175
0
              cr_col_buf + i * (2 - chroma_subsamp_y) * (2 - chroma_subsamp_x),
1176
0
              2, (2 - chroma_subsamp_x),
1177
0
              AOMMIN(luma_subblock_size_y >> 1, height / 2 - y) - i, 1,
1178
0
              bit_depth, chroma_subsamp_y, chroma_subsamp_x, mc_identity);
1179
0
        } else {
1180
0
          add_noise_to_block(
1181
0
              params, luma + ((y + i) << 1) * luma_stride + (x << 1),
1182
0
              cb + ((y + i) << (1 - chroma_subsamp_y)) * chroma_stride +
1183
0
                  (x << (1 - chroma_subsamp_x)),
1184
0
              cr + ((y + i) << (1 - chroma_subsamp_y)) * chroma_stride +
1185
0
                  (x << (1 - chroma_subsamp_x)),
1186
0
              luma_stride, chroma_stride, y_col_buf + i * 4,
1187
0
              cb_col_buf + i * (2 - chroma_subsamp_y) * (2 - chroma_subsamp_x),
1188
0
              cr_col_buf + i * (2 - chroma_subsamp_y) * (2 - chroma_subsamp_x),
1189
0
              2, (2 - chroma_subsamp_x),
1190
0
              AOMMIN(luma_subblock_size_y >> 1, height / 2 - y) - i, 1,
1191
0
              bit_depth, chroma_subsamp_y, chroma_subsamp_x, mc_identity);
1192
0
        }
1193
0
      }
1194
1195
0
      if (overlap && y) {
1196
0
        if (x) {
1197
0
          hor_boundary_overlap(y_line_buf + (x << 1), luma_stride, y_col_buf, 2,
1198
0
                               y_line_buf + (x << 1), luma_stride, 2, 2);
1199
1200
0
          hor_boundary_overlap(cb_line_buf + x * (2 >> chroma_subsamp_x),
1201
0
                               chroma_stride, cb_col_buf, 2 >> chroma_subsamp_x,
1202
0
                               cb_line_buf + x * (2 >> chroma_subsamp_x),
1203
0
                               chroma_stride, 2 >> chroma_subsamp_x,
1204
0
                               2 >> chroma_subsamp_y);
1205
1206
0
          hor_boundary_overlap(cr_line_buf + x * (2 >> chroma_subsamp_x),
1207
0
                               chroma_stride, cr_col_buf, 2 >> chroma_subsamp_x,
1208
0
                               cr_line_buf + x * (2 >> chroma_subsamp_x),
1209
0
                               chroma_stride, 2 >> chroma_subsamp_x,
1210
0
                               2 >> chroma_subsamp_y);
1211
0
        }
1212
1213
0
        hor_boundary_overlap(
1214
0
            y_line_buf + ((x ? x + 1 : 0) << 1), luma_stride,
1215
0
            luma_grain_block + luma_offset_y * luma_grain_stride +
1216
0
                luma_offset_x + (x ? 2 : 0),
1217
0
            luma_grain_stride, y_line_buf + ((x ? x + 1 : 0) << 1), luma_stride,
1218
0
            AOMMIN(luma_subblock_size_x - ((x ? 1 : 0) << 1),
1219
0
                   width - ((x ? x + 1 : 0) << 1)),
1220
0
            2);
1221
1222
0
        hor_boundary_overlap(
1223
0
            cb_line_buf + ((x ? x + 1 : 0) << (1 - chroma_subsamp_x)),
1224
0
            chroma_stride,
1225
0
            cb_grain_block + chroma_offset_y * chroma_grain_stride +
1226
0
                chroma_offset_x + ((x ? 1 : 0) << (1 - chroma_subsamp_x)),
1227
0
            chroma_grain_stride,
1228
0
            cb_line_buf + ((x ? x + 1 : 0) << (1 - chroma_subsamp_x)),
1229
0
            chroma_stride,
1230
0
            AOMMIN(chroma_subblock_size_x -
1231
0
                       ((x ? 1 : 0) << (1 - chroma_subsamp_x)),
1232
0
                   (width - ((x ? x + 1 : 0) << 1)) >> chroma_subsamp_x),
1233
0
            2 >> chroma_subsamp_y);
1234
1235
0
        hor_boundary_overlap(
1236
0
            cr_line_buf + ((x ? x + 1 : 0) << (1 - chroma_subsamp_x)),
1237
0
            chroma_stride,
1238
0
            cr_grain_block + chroma_offset_y * chroma_grain_stride +
1239
0
                chroma_offset_x + ((x ? 1 : 0) << (1 - chroma_subsamp_x)),
1240
0
            chroma_grain_stride,
1241
0
            cr_line_buf + ((x ? x + 1 : 0) << (1 - chroma_subsamp_x)),
1242
0
            chroma_stride,
1243
0
            AOMMIN(chroma_subblock_size_x -
1244
0
                       ((x ? 1 : 0) << (1 - chroma_subsamp_x)),
1245
0
                   (width - ((x ? x + 1 : 0) << 1)) >> chroma_subsamp_x),
1246
0
            2 >> chroma_subsamp_y);
1247
1248
0
        if (use_high_bit_depth) {
1249
0
          add_noise_to_block_hbd(
1250
0
              params, (uint16_t *)luma + (y << 1) * luma_stride + (x << 1),
1251
0
              (uint16_t *)cb + (y << (1 - chroma_subsamp_y)) * chroma_stride +
1252
0
                  (x << ((1 - chroma_subsamp_x))),
1253
0
              (uint16_t *)cr + (y << (1 - chroma_subsamp_y)) * chroma_stride +
1254
0
                  (x << ((1 - chroma_subsamp_x))),
1255
0
              luma_stride, chroma_stride, y_line_buf + (x << 1),
1256
0
              cb_line_buf + (x << (1 - chroma_subsamp_x)),
1257
0
              cr_line_buf + (x << (1 - chroma_subsamp_x)), luma_stride,
1258
0
              chroma_stride, 1,
1259
0
              AOMMIN(luma_subblock_size_x >> 1, width / 2 - x), bit_depth,
1260
0
              chroma_subsamp_y, chroma_subsamp_x, mc_identity);
1261
0
        } else {
1262
0
          add_noise_to_block(
1263
0
              params, luma + (y << 1) * luma_stride + (x << 1),
1264
0
              cb + (y << (1 - chroma_subsamp_y)) * chroma_stride +
1265
0
                  (x << ((1 - chroma_subsamp_x))),
1266
0
              cr + (y << (1 - chroma_subsamp_y)) * chroma_stride +
1267
0
                  (x << ((1 - chroma_subsamp_x))),
1268
0
              luma_stride, chroma_stride, y_line_buf + (x << 1),
1269
0
              cb_line_buf + (x << (1 - chroma_subsamp_x)),
1270
0
              cr_line_buf + (x << (1 - chroma_subsamp_x)), luma_stride,
1271
0
              chroma_stride, 1,
1272
0
              AOMMIN(luma_subblock_size_x >> 1, width / 2 - x), bit_depth,
1273
0
              chroma_subsamp_y, chroma_subsamp_x, mc_identity);
1274
0
        }
1275
0
      }
1276
1277
0
      int i = overlap && y ? 1 : 0;
1278
0
      int j = overlap && x ? 1 : 0;
1279
1280
0
      if (use_high_bit_depth) {
1281
0
        add_noise_to_block_hbd(
1282
0
            params,
1283
0
            (uint16_t *)luma + ((y + i) << 1) * luma_stride + ((x + j) << 1),
1284
0
            (uint16_t *)cb +
1285
0
                ((y + i) << (1 - chroma_subsamp_y)) * chroma_stride +
1286
0
                ((x + j) << (1 - chroma_subsamp_x)),
1287
0
            (uint16_t *)cr +
1288
0
                ((y + i) << (1 - chroma_subsamp_y)) * chroma_stride +
1289
0
                ((x + j) << (1 - chroma_subsamp_x)),
1290
0
            luma_stride, chroma_stride,
1291
0
            luma_grain_block + (luma_offset_y + (i << 1)) * luma_grain_stride +
1292
0
                luma_offset_x + (j << 1),
1293
0
            cb_grain_block +
1294
0
                (chroma_offset_y + (i << (1 - chroma_subsamp_y))) *
1295
0
                    chroma_grain_stride +
1296
0
                chroma_offset_x + (j << (1 - chroma_subsamp_x)),
1297
0
            cr_grain_block +
1298
0
                (chroma_offset_y + (i << (1 - chroma_subsamp_y))) *
1299
0
                    chroma_grain_stride +
1300
0
                chroma_offset_x + (j << (1 - chroma_subsamp_x)),
1301
0
            luma_grain_stride, chroma_grain_stride,
1302
0
            AOMMIN(luma_subblock_size_y >> 1, height / 2 - y) - i,
1303
0
            AOMMIN(luma_subblock_size_x >> 1, width / 2 - x) - j, bit_depth,
1304
0
            chroma_subsamp_y, chroma_subsamp_x, mc_identity);
1305
0
      } else {
1306
0
        add_noise_to_block(
1307
0
            params, luma + ((y + i) << 1) * luma_stride + ((x + j) << 1),
1308
0
            cb + ((y + i) << (1 - chroma_subsamp_y)) * chroma_stride +
1309
0
                ((x + j) << (1 - chroma_subsamp_x)),
1310
0
            cr + ((y + i) << (1 - chroma_subsamp_y)) * chroma_stride +
1311
0
                ((x + j) << (1 - chroma_subsamp_x)),
1312
0
            luma_stride, chroma_stride,
1313
0
            luma_grain_block + (luma_offset_y + (i << 1)) * luma_grain_stride +
1314
0
                luma_offset_x + (j << 1),
1315
0
            cb_grain_block +
1316
0
                (chroma_offset_y + (i << (1 - chroma_subsamp_y))) *
1317
0
                    chroma_grain_stride +
1318
0
                chroma_offset_x + (j << (1 - chroma_subsamp_x)),
1319
0
            cr_grain_block +
1320
0
                (chroma_offset_y + (i << (1 - chroma_subsamp_y))) *
1321
0
                    chroma_grain_stride +
1322
0
                chroma_offset_x + (j << (1 - chroma_subsamp_x)),
1323
0
            luma_grain_stride, chroma_grain_stride,
1324
0
            AOMMIN(luma_subblock_size_y >> 1, height / 2 - y) - i,
1325
0
            AOMMIN(luma_subblock_size_x >> 1, width / 2 - x) - j, bit_depth,
1326
0
            chroma_subsamp_y, chroma_subsamp_x, mc_identity);
1327
0
      }
1328
1329
0
      if (overlap) {
1330
0
        if (x) {
1331
          // Copy overlapped column bufer to line buffer
1332
0
          copy_area(y_col_buf + (luma_subblock_size_y << 1), 2,
1333
0
                    y_line_buf + (x << 1), luma_stride, 2, 2);
1334
1335
0
          copy_area(
1336
0
              cb_col_buf + (chroma_subblock_size_y << (1 - chroma_subsamp_x)),
1337
0
              2 >> chroma_subsamp_x,
1338
0
              cb_line_buf + (x << (1 - chroma_subsamp_x)), chroma_stride,
1339
0
              2 >> chroma_subsamp_x, 2 >> chroma_subsamp_y);
1340
1341
0
          copy_area(
1342
0
              cr_col_buf + (chroma_subblock_size_y << (1 - chroma_subsamp_x)),
1343
0
              2 >> chroma_subsamp_x,
1344
0
              cr_line_buf + (x << (1 - chroma_subsamp_x)), chroma_stride,
1345
0
              2 >> chroma_subsamp_x, 2 >> chroma_subsamp_y);
1346
0
        }
1347
1348
        // Copy grain to the line buffer for overlap with a bottom block
1349
0
        copy_area(
1350
0
            luma_grain_block +
1351
0
                (luma_offset_y + luma_subblock_size_y) * luma_grain_stride +
1352
0
                luma_offset_x + ((x ? 2 : 0)),
1353
0
            luma_grain_stride, y_line_buf + ((x ? x + 1 : 0) << 1), luma_stride,
1354
0
            AOMMIN(luma_subblock_size_x, width - (x << 1)) - (x ? 2 : 0), 2);
1355
1356
0
        copy_area(cb_grain_block +
1357
0
                      (chroma_offset_y + chroma_subblock_size_y) *
1358
0
                          chroma_grain_stride +
1359
0
                      chroma_offset_x + (x ? 2 >> chroma_subsamp_x : 0),
1360
0
                  chroma_grain_stride,
1361
0
                  cb_line_buf + ((x ? x + 1 : 0) << (1 - chroma_subsamp_x)),
1362
0
                  chroma_stride,
1363
0
                  AOMMIN(chroma_subblock_size_x,
1364
0
                         ((width - (x << 1)) >> chroma_subsamp_x)) -
1365
0
                      (x ? 2 >> chroma_subsamp_x : 0),
1366
0
                  2 >> chroma_subsamp_y);
1367
1368
0
        copy_area(cr_grain_block +
1369
0
                      (chroma_offset_y + chroma_subblock_size_y) *
1370
0
                          chroma_grain_stride +
1371
0
                      chroma_offset_x + (x ? 2 >> chroma_subsamp_x : 0),
1372
0
                  chroma_grain_stride,
1373
0
                  cr_line_buf + ((x ? x + 1 : 0) << (1 - chroma_subsamp_x)),
1374
0
                  chroma_stride,
1375
0
                  AOMMIN(chroma_subblock_size_x,
1376
0
                         ((width - (x << 1)) >> chroma_subsamp_x)) -
1377
0
                      (x ? 2 >> chroma_subsamp_x : 0),
1378
0
                  2 >> chroma_subsamp_y);
1379
1380
        // Copy grain to the column buffer for overlap with the next block to
1381
        // the right
1382
1383
0
        copy_area(luma_grain_block + luma_offset_y * luma_grain_stride +
1384
0
                      luma_offset_x + luma_subblock_size_x,
1385
0
                  luma_grain_stride, y_col_buf, 2, 2,
1386
0
                  AOMMIN(luma_subblock_size_y + 2, height - (y << 1)));
1387
1388
0
        copy_area(cb_grain_block + chroma_offset_y * chroma_grain_stride +
1389
0
                      chroma_offset_x + chroma_subblock_size_x,
1390
0
                  chroma_grain_stride, cb_col_buf, 2 >> chroma_subsamp_x,
1391
0
                  2 >> chroma_subsamp_x,
1392
0
                  AOMMIN(chroma_subblock_size_y + (2 >> chroma_subsamp_y),
1393
0
                         (height - (y << 1)) >> chroma_subsamp_y));
1394
1395
0
        copy_area(cr_grain_block + chroma_offset_y * chroma_grain_stride +
1396
0
                      chroma_offset_x + chroma_subblock_size_x,
1397
0
                  chroma_grain_stride, cr_col_buf, 2 >> chroma_subsamp_x,
1398
0
                  2 >> chroma_subsamp_x,
1399
0
                  AOMMIN(chroma_subblock_size_y + (2 >> chroma_subsamp_y),
1400
0
                         (height - (y << 1)) >> chroma_subsamp_y));
1401
0
      }
1402
0
    }
1403
0
  }
1404
1405
0
  dealloc_arrays(params, &pred_pos_luma, &pred_pos_chroma, &luma_grain_block,
1406
0
                 &cb_grain_block, &cr_grain_block, &y_line_buf, &cb_line_buf,
1407
0
                 &cr_line_buf, &y_col_buf, &cb_col_buf, &cr_col_buf);
1408
0
  return 0;
1409
0
}