diff --git a/aom_dsp/aom_dsp.cmake b/aom_dsp/aom_dsp.cmake
index e21a6d9..8ffb7ff 100644
--- a/aom_dsp/aom_dsp.cmake
+++ b/aom_dsp/aom_dsp.cmake
@@ -293,6 +293,12 @@
       "${AOM_ROOT}/aom_dsp/daalaboolreader.h"
       "${AOM_ROOT}/aom_dsp/entdec.c"
       "${AOM_ROOT}/aom_dsp/entdec.h")
+
+  set(AOM_DSP_DECODER_SOURCES
+      ${AOM_DSP_DECODER_SOURCES}
+      "${AOM_ROOT}/aom_dsp/grain_synthesis.c"
+      "${AOM_ROOT}/aom_dsp/grain_synthesis.h")
+
 endif ()
 
 if (CONFIG_AV1_ENCODER)
diff --git a/aom_dsp/grain_synthesis.c b/aom_dsp/grain_synthesis.c
new file mode 100644
index 0000000..8dbc242
--- /dev/null
+++ b/aom_dsp/grain_synthesis.c
@@ -0,0 +1,1233 @@
+/*
+ * Copyright (c) 2016, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 2 Clause License and
+ * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+ * was not distributed with this source code in the LICENSE file, you can
+ * obtain it at www.aomedia.org/license/software. If the Alliance for Open
+ * Media Patent License 1.0 was not distributed with this source code in the
+ * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+ */
+
+/*!\file
+ * \brief Describes film grain parameters and film grain synthesis
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "aom_dsp/grain_synthesis.h"
+#include "aom_mem/aom_mem.h"
+
+// Samples with Gaussian distribution in the range of [-2048, 2047] (12 bits)
+// with zero mean and standard deviation of about 512.
+// should be divided by 4 for 10-bit range and 16 for 8-bit range.
+static const int gaussian_sequence[2048] = {
+  711,   -320,  81,    420,   447,   1637,  -197,  410,   128,   952,   -937,
+  -250,  94,    320,   32,    1021,  -437,  214,   452,   -306,  515,   262,
+  -81,   169,   371,   748,   65,    326,   250,   -398,  1012,  -513,  -316,
+  -803,  -1051, 885,   -373,  -163,  900,   85,    433,   -725,  -61,   -322,
+  179,   96,    130,   -628,  432,   1103,  345,   -143,  -346,  373,   159,
+  458,   -511,  -722,  -604,  911,   -588,  924,   -323,  -442,  19,    -32,
+  211,   437,   417,   305,   767,   246,   806,   492,   52,    -488,  -606,
+  655,   -78,   119,   129,   -711,  721,   191,   307,   548,   100,   -469,
+  -229,  583,   -66,   12,    149,   -119,  619,   -488,  -739,  -425,  -786,
+  -95,   -597,  -90,   -8,    -49,   568,   -954,  252,   -177,  605,   -117,
+  780,   552,   -211,  288,   375,   -371,  -705,  -130,  307,   45,    21,
+  -507,  -551,  169,   375,   321,   45,    -332,  634,   348,   -598,  26,
+  369,   451,   -739,  -814,  -410,  -222,  286,   746,   51,    1308,  -196,
+  -605,  -468,  -31,   691,   277,   92,    -34,   -770,  -938,  451,   -218,
+  -728,  1164,  -709,  -1613, -156,  800,   89,    367,   -153,  -409,  -147,
+  -116,  152,   -575,  317,   715,   -510,  -794,  -590,  140,   -477,  -625,
+  -146,  550,   443,   397,   -1320, 340,   -172,  -173,  -6,    269,   -85,
+  161,   420,   -393,  351,   43,    152,   -757,  -60,   -480,  598,   208,
+  -154,  129,   -555,  305,   -45,   398,   89,    222,   -237,  -375,  1076,
+  -556,  -1171, -376,  495,   -537,  287,   879,   -365,  -815,  579,   -138,
+  164,   -188,  811,   309,   287,   -300,  -241,  -189,  -1026, -1603, -1364,
+  151,   -370,  -344,  -974,  -277,  982,   296,   -428,  -638,  262,   -3,
+  -1445, -31,   533,   882,   -410,  189,   -321,  -390,  -814,  -597,  340,
+  957,   123,   29,    531,   -689,  407,   -483,  -371,  783,   68,    593,
+  540,   -472,  311,   -31,   595,   566,   -243,  524,   -212,  -617,  287,
+  -63,   -461,  -593,  -434,  1218,  -310,  994,   691,   228,   -641,  -501,
+  41,    74,    205,   -657,  -67,   -324,  -4,    -946,  850,   -1065, 370,
+  135,   -853,  -259,  -82,   23,    -491,  521,   537,   -149,  -359,  446,
+  447,   468,   -1017, -322,  -195,  250,   152,   -370,  198,   541,   293,
+  -721,  -140,  -585,  -335,  -4,    414,   -793,  -563,  -420,  367,   536,
+  -464,  491,   802,   -227,  575,   -379,  36,    668,   -444,  126,   146,
+  348,   171,   -522,  -915,  -52,   70,    104,   -332,  605,   470,   -764,
+  232,   316,   72,    400,   1697,  600,   529,   -5,    100,   119,   -491,
+  -414,  1119,  -221,  658,   329,   -280,  -210,  329,   492,   397,   233,
+  -49,   -590,  38,    365,   669,   1199,  -35,   44,    357,   304,   -404,
+  -3,    -102,  111,   -204,  111,   -736,  1148,  -619,  -314,  148,   579,
+  34,    -566,  450,   -526,  208,   -794,  -30,   -327,  -180,  164,   170,
+  181,   349,   64,    -101,  -1142, 154,   33,    1127,  -104,  333,   390,
+  941,   474,   -84,   105,   1207,  478,   575,   -414,  1554,  -298,  1077,
+  947,   -458,  312,   -258,  -701,  -27,   934,   329,   1047,  -345,  -870,
+  353,   506,   -507,  140,   160,   -243,  -717,  -299,  564,   -291,  -70,
+  -446,  12,    -335,  173,   -365,  -895,  273,   354,   572,   401,   -90,
+  -333,  513,   -418,  -225,  150,   16,    832,   -856,  19,    -200,  -818,
+  423,   545,   -320,  246,   -159,  1095,  -24,   474,   500,   442,   -751,
+  250,   31,    390,   1117,  -308,  560,   -190,  -228,  -1230, -79,   121,
+  806,   -657,  694,   -999,  -17,   -191,  475,   483,   -1369, -76,   293,
+  56,    -161,  -793,  630,   381,   176,   374,   368,   374,   265,   146,
+  -363,  170,   8,     358,   883,   -458,  -30,   -299,  285,   -439,  -361,
+  -255,  -71,   -141,  -319,  -178,  42,    -269,  -512,  42,    272,   268,
+  12,    -174,  -780,  -143,  201,   108,   578,   -905,  78,    -183,  -522,
+  345,   -435,  -291,  399,   888,   422,   10,    -221,  -683,  570,   -3,
+  264,   163,   146,   -148,  708,   140,   269,   334,   -1045, -820,  942,
+  -350,  289,   -381,  1262,  -152,  1054,  336,   246,   -107,  157,   23,
+  561,   -389,  492,   55,    -318,  339,   561,   787,   -911,  309,   118,
+  75,    80,    -10,   -198,  -7,    -15,   -411,  341,   386,   -120,  287,
+  -33,   -22,   -753,  465,   271,   245,   517,   -414,  -526,  9,     146,
+  535,   -377,  319,   281,   13,    126,   258,   112,   18,    -809,  545,
+  -217,  546,   500,   -161,  139,   -741,  112,   -144,  -565,  -266,  246,
+  1308,  300,   -357,  1172,  311,   -290,  136,   855,   414,   258,   165,
+  138,   -56,   8,     -231,  790,   -363,  338,   618,   -366,  -86,   158,
+  632,   552,   -568,  -170,  -284,  -22,   342,   -87,   669,   -230,  387,
+  -1240, 222,   435,   -247,  -965,  -172,  -419,  428,   -735,  465,   32,
+  -508,  16,    -428,  -161,  1091,  260,   -416,  -580,  -283,  -431,  -183,
+  -952,  -853,  166,   1148,  590,   -362,  -217,  -476,  -400,  341,   -413,
+  -543,  46,    247,   -184,  -94,   -475,  -503,  174,   -225,  85,    -459,
+  -124,  269,   436,   445,   -958,  546,   59,    167,   226,   13,    -757,
+  -158,  -289,  175,   109,   456,   -34,   -39,   45,    677,   87,    792,
+  -89,   -401,  1132,  -319,  45,    143,   -344,  -1164, 539,   -72,   -399,
+  301,   255,   -587,  -112,  -476,  350,   204,   650,   232,   -240,  524,
+  250,   -242,  -229,  -449,  -460,  895,   -754,  -167,  286,   -904,  216,
+  572,   -180,  1082,  -311,  202,   442,   674,   86,    -841,  713,   -923,
+  1640,  633,   -624,  195,   603,   33,    -760,  66,    133,   -967,  -6,
+  -597,  317,   -311,  577,   -410,  -657,  323,   -373,  23,    -711,  1230,
+  -740,  406,   594,   -41,   -493,  -1113, -491,  488,   699,   -419,  -462,
+  -203,  -133,  -346,  -407,  399,   -127,  225,   -29,   193,   -351,  650,
+  -276,  352,   -577,  1060,  90,    -475,  -469,  26,    761,   401,   -447,
+  -154,  1043,  377,   -21,   546,   -199,  290,   388,   -544,  1060,  -12,
+  555,   -484,  12,    -185,  225,   -1053, 492,   672,   491,   -650,  -83,
+  -8,    310,   -352,  477,   404,   406,   -485,  75,    733,   268,   121,
+  14,    -331,  28,    234,   -282,  -150,  -558,  709,   190,   414,   66,
+  -11,   -49,   -113,  130,   -196,  551,   677,   532,   -122,  57,    -165,
+  167,   74,    -257,  812,   -1073, -767,  -616,  282,   219,   326,   -351,
+  147,   762,   -301,  41,    1015,  29,    -383,  -21,   -1384, 110,   -785,
+  103,   -52,   -151,  -584,  -850,  -328,  -571,  449,   230,   -208,  253,
+  409,   73,    -262,  -141,  179,   -135,  1248,  143,   -570,  -169,  377,
+  -66,   119,   335,   530,   582,   -493,  235,   391,   -1227, -1067, 780,
+  -160,  409,   52,    270,   1210,  69,    58,    1390,  733,   -240,  119,
+  -111,  -265,  91,    -256,  -84,   -563,  521,   -6,    28,    239,   -720,
+  -855,  -407,  -661,  -682,  -814,  442,   -405,  319,   877,   -140,  -120,
+  -115,  -302,  -134,  222,   -448,  -405,  -185,  -20,   193,   97,    -266,
+  440,   850,   -429,  -645,  -388,  -462,  -589,  659,   -421,  -96,   57,
+  212,   407,   -259,  -451,  276,   387,   455,   -42,   -624,  333,   -690,
+  -102,  818,   368,   -194,  -214,  -35,   236,   -589,  270,   21,    -197,
+  507,   -706,  124,   -32,   -226,  8,     301,   79,    9,     -177,  606,
+  197,   -269,  -1075, -162,  1052,  499,   -51,   1312,  -1074, 52,    -141,
+  351,   -261,  -898,  -513,  -253,  45,    844,   534,   199,   -176,  -490,
+  -305,  894,   -229,  41,    328,   -73,   -57,   -4,    517,   -522,  126,
+  -50,   -63,   478,   -787,  -377,  192,   470,   -449,  396,   -129,  233,
+  411,   118,   257,   174,   508,   -542,  440,   -446,  24,    407,   570,
+  -81,   -41,   14,    -696,  273,   -584,  -398,  -186,  -96,   -860,  -69,
+  223,   -905,  -309,  70,    91,    433,   -1017, -228,  60,    -655,  -388,
+  -357,  -500,  -1595, 486,   824,   967,   -52,   -46,   265,   -540,  -230,
+  -621,  334,   -420,  -756,  848,   -191,  -1000, -780,  146,   -666,  270,
+  -549,  600,   -202,  40,    834,   -586,  94,    104,   367,   112,   591,
+  -204,  128,   259,   418,   456,   -257,  726,   405,   827,   -77,   89,
+  833,   -372,  421,   176,   -138,  86,    -414,  302,   -457,  -1222, 431,
+  -271,  117,   196,   -487,  -1082, -762,  -823,  -703,  288,   -290,  321,
+  34,    -85,   563,   -327,  -7,    -1304, 892,   505,   258,   -154,  -669,
+  108,   -543,  352,   273,   334,   404,   -464,  -529,  335,   -271,  -34,
+  -736,  165,   -636,  -642,  -7,    -521,  -921,  -1262, -324,  533,   233,
+  603,   89,    -352,  219,   379,   -182,  -180,  -43,   -60,   1208,  247,
+  -215,  -484,  417,   384,   -90,   757,   -137,  224,   296,   475,   -480,
+  903,   667,   -1184, -69,   -299,  502,   990,   -56,   243,   580,   -16,
+  -248,  346,   -148,  723,   -423,  150,   198,   -80,   -136,  681,   -157,
+  199,   198,   -37,   -214,  -356,  65,    657,   99,    -1086, 329,   733,
+  200,   1099,  1514,  -315,  812,   284,   -579,  -465,  871,   -296,  983,
+  797,   -36,   284,   157,   144,   940,   333,   -298,  582,   -484,  -114,
+  -75,   263,   -895,  -38,   -858,  -196,  -681,  -383,  -261,  -8,    -85,
+  453,   558,   -198,  454,   558,   -131,  -342,  -769,  864,   -382,  504,
+  938,   603,   -437,  -123,  -741,  141,   595,   113,   -523,  -2,    32,
+  -224,  -481,  -19,   -20,   -43,   244,   408,   946,   -1092, 27,    664,
+  34,    328,   -768,  841,   308,   -3,    -747,  631,   -431,  -104,  551,
+  -219,  372,   618,   855,   104,   -548,  54,    -251,  -529,  306,   -444,
+  -927,  -300,  -25,   51,    256,   112,   -248,  -318,  68,    154,   179,
+  -6,    -79,   417,   -64,   -233,  -438,  -22,   114,   -243,  -284,  -748,
+  5,     794,   -345,  -373,  -317,  -173,  73,    -273,  -396,  -168,  632,
+  30,    328,   -753,  205,   -69,   223,   -546,  -797,  -334,  -242,  362,
+  376,   -131,  -15,   -989,  -77,   -578,  -443,  -848,  -244,  18,    141,
+  -378,  699,   -907,  -198,  103,   1029,  575,   25,    -440,  662,   -631,
+  917,   164,   378,   -21,   -973,  68,    354,   -788,  213,   -592,  495,
+  349,   608,   180,   312,   315,   848,   -78,   -24,   -311,  95,    -141,
+  -795,  561,   -383,  1456,  -136,  -228,  -578,  150,   -840,  -149,  -286,
+  25,    738,   608,   762,   221,   -586,  -44,   102,   -47,   280,   -152,
+  -164,  -147,  360,   1001,  348,   391,   233,   -605,  283,   -52,   -139,
+  -640,  -594,  816,   -401,  835,   -81,   -152,  223,   -178,  -46,   -166,
+  -16,   266,   434,   127,   99,    -468,  472,   -6,    412,   9,     100,
+  489,   -852,  -1052, -277,  1017,  353,   -259,  -537,  568,   45,    -152,
+  -188,  713,   860,   -60,   -767,  -41,   -490,  689,   -933,  689,   -67,
+  -751,  -276,  -411,  842,   -472,  -556,  178,   -517,  228,   -474,  348,
+  74,    982,   299,   -590,  805,   518,   303,   -548,  -261,  743,   1179,
+  480,   286,   280,   474,   -53,   478,   -161,  339,   -44,   374,   17,
+  -800,  -122,  287,   -825,  -272,  196,   -19,   -348,  -49,   -499,  273,
+  -224,  -11,   -846,  485,   1,     86,    -1027, 203,   -605,  -1159, -42,
+  171,   520,   -75,   84,    -759,  -519,  -473,  -650,  348,   -228,  -68,
+  592,   330,   -168,  -606,  318,   146,   -255,  -688,  -500,  -540,  823,
+  -250,  -703,  632,   177,   -315,  -212,  97,    -160,  107,   -640,  449,
+  -72,   -875,  511,   174,   207,   901,   678,   -889,  -124,  -295,  -1132,
+  -911,  -251,  -370,  537,   1298,  -165,  326,   518,   -157,  333,   354,
+  -523,  -122,  -318,  22,    -200,  -402,  135,   316,   11,    317,   -570,
+  -288,  535,   575,   -416,  189,   -127,  -218,  466,   414,   328,   257,
+  -665,  -1015, -275,  1230,  -493,  -1791, -883,  362,   78,    300,   -31,
+  -885,  -149,  410,   -727,  -387,  -890,  -304,  -44,   -441,  699,   -110,
+  251,   960,   686,   367,   60,    -508,  331,   382,   138,   -151,  -745,
+  32,    618,   -131,  462,   -244,  383,   996,   -493,  -150,  -594,  500,
+  -363,  102,   662,   137,   -613,  512,   402,   967,   936,   371,   666,
+  343,   -171,  56,    -224,  -719,  731,   -874,  47,    -254,  639,   324,
+  -176,  191,   -376,  -295,  678,   703,   113,   -386,  -461,  285,   -147,
+  -990,  -701,  293,   -675,  -576,  298,   -838,  713,   -489,  -386,  617,
+  818,   548,   -281,  59,    201,   253,   657,   -537,  -554,  -224,  -489,
+  -854,  -56,   -261,  660,   312,   282,   -778,  -73,   680,   13,    -37,
+  -202,  999,   -498,  215,   -194,  -334,  -201,  626,   -823,  -339,  639,
+  -355,  655,   -980,  -614,  781,   -319,  -439,  -25,   -7,    -383,  522,
+  228,   153,   766,   913,   -130,  717,   538,   -489,  353,   411,   239,
+  509,   -420,  -850,  883,   461,   928,   368,   -702,  -1114, -35,   112,
+  -153,  642,   55,    -494,  -621,  -774,  -148,  818,   -107,  -454,  -207,
+  88,    -569,  385,   793,   215,   549,   -320,  936,   -312,  -690,  973,
+  -562,  -411,  675,   250,   153,   90,    -372,  547,   -1029, 503,   -60,
+  263,   -322,  401,   621,   388,   511,   296,   173,   -78,   -416,  98,
+  -69,   -368,  801,   -160,  871,   248,   44,    617,   1098,  175,   312,
+  -750,  -149,  866,   -151,  406,   -428,  221,   -214,  -287,  -822,  262,
+  -783,  682,   -179,  752,   445,   -197,  -181,  -825,  -1293, 213,   -142,
+  211,   -340,  -606,  892,   -567,  -235,  781,   -703,  -276,  739,   565,
+  -262,  433,   -616,  -530,  427,   -532,  931,   -49,   -81,   -1357, -402,
+  530,   303,   59,    876,   -377,  -998,  339,   -680,  -49,   -157,  -213,
+  -850,  507,   -290,  196,   622,   -523,  268,   370,   -132,  -749,  91,
+  -558,  5,     -240,  -55,   -8,    -447,  -291,  552,   -238,  283,   -93,
+  224,   873,   263,   -416,  229,   -229,  202,   -113,  839,   396,   -143,
+  -184,  564,   186,   240,   -96,   -791,  225,   -68,   532,   9,     -441,
+  670,   156,   703,   -322,  -1190, -362,  -1010, -633,  -265,  -484,  20,
+  -369,  -325,  -379,  -286,  -67,   -122,  449,   -845,  81,    436,   116,
+  -521,  -59,   -1379, 400,   852,   -471,  -880,  638,   -875,  155,   -375,
+  -183,  1032,  63,    -266,  -272,  298,   -186,  504,   273,   235,   116,
+  364,   671,   -619,  -174,  -740,  -535,  394,   124,   -877,  -288,  -146,
+  37,    641,   -183,  498,   142,   -109,  -92,   540,   -587,  -170,  -469,
+  -1347, 852,   -313,  176,   366,   220,   -403,  -384,  135,   -321,  706,
+  254,   575,   511,   -6,    -363,  -497,  -611,  -457,  475,   245,   374,
+  1811,  123
+};
+
+static const int gauss_bits = 11;
+
+static const int luma_subblock_size = 32;
+static const int chroma_subblock_size = 16;
+
+static const int min_luma_legal_range = 16;
+static const int max_luma_legal_range = 235;
+
+static const int min_chroma_legal_range = 16;
+static const int max_chroma_legal_range = 240;
+
+static int scaling_lut_y[256];
+static int scaling_lut_cb[256];
+static int scaling_lut_cr[256];
+
+static int grain_center;
+static int grain_min;
+static int grain_max;
+
+static uint16_t random_register = 0;  // random number generator register
+
+static void init_arrays(aom_film_grain_t *params, int luma_stride,
+                        int chroma_stride, int ***pred_pos_luma_p,
+                        int ***pred_pos_chroma_p, int **luma_grain_block,
+                        int **cb_grain_block, int **cr_grain_block,
+                        int **y_line_buf, int **cb_line_buf, int **cr_line_buf,
+                        int **y_col_buf, int **cb_col_buf, int **cr_col_buf,
+                        int luma_grain_samples, int chroma_grain_samples) {
+  memset(scaling_lut_y, 0, sizeof(*scaling_lut_y) * 256);
+  memset(scaling_lut_cb, 0, sizeof(*scaling_lut_cb) * 256);
+  memset(scaling_lut_cr, 0, sizeof(*scaling_lut_cr) * 256);
+
+  int num_pos_luma = 2 * params->ar_coeff_lag * (params->ar_coeff_lag + 1);
+  int num_pos_chroma = num_pos_luma + 1;
+
+  int **pred_pos_luma;
+  int **pred_pos_chroma;
+
+  pred_pos_luma = (int **)aom_malloc(sizeof(*pred_pos_luma) * num_pos_luma);
+
+  for (int row = 0; row < num_pos_luma; row++) {
+    pred_pos_luma[row] = (int *)aom_malloc(sizeof(**pred_pos_luma) * 3);
+  }
+
+  pred_pos_chroma =
+      (int **)aom_malloc(sizeof(*pred_pos_chroma) * num_pos_chroma);
+
+  for (int row = 0; row < num_pos_chroma; row++) {
+    pred_pos_chroma[row] = (int *)aom_malloc(sizeof(**pred_pos_chroma) * 3);
+  }
+
+  int pos_ar_index = 0;
+
+  for (int row = -params->ar_coeff_lag; row < 0; row++) {
+    for (int col = -params->ar_coeff_lag; col < params->ar_coeff_lag + 1;
+         col++) {
+      pred_pos_luma[pos_ar_index][0] = row;
+      pred_pos_luma[pos_ar_index][1] = col;
+      pred_pos_luma[pos_ar_index][2] = 0;
+
+      pred_pos_chroma[pos_ar_index][0] = row;
+      pred_pos_chroma[pos_ar_index][1] = col;
+      pred_pos_chroma[pos_ar_index][2] = 0;
+      ++pos_ar_index;
+    }
+  }
+
+  for (int col = -params->ar_coeff_lag; col < 0; col++) {
+    pred_pos_luma[pos_ar_index][0] = 0;
+    pred_pos_luma[pos_ar_index][1] = col;
+    pred_pos_luma[pos_ar_index][2] = 0;
+
+    pred_pos_chroma[pos_ar_index][0] = 0;
+    pred_pos_chroma[pos_ar_index][1] = col;
+    pred_pos_chroma[pos_ar_index][2] = 0;
+
+    ++pos_ar_index;
+  }
+
+  pred_pos_chroma[pos_ar_index][0] = 0;
+  pred_pos_chroma[pos_ar_index][1] = 0;
+  pred_pos_chroma[pos_ar_index][2] = 1;
+
+  *pred_pos_luma_p = pred_pos_luma;
+  *pred_pos_chroma_p = pred_pos_chroma;
+
+  *y_line_buf = (int *)aom_malloc(sizeof(**y_line_buf) * luma_stride * 2);
+  *cb_line_buf = (int *)aom_malloc(sizeof(**cb_line_buf) * chroma_stride);
+  *cr_line_buf = (int *)aom_malloc(sizeof(**cr_line_buf) * chroma_stride);
+
+  *y_col_buf =
+      (int *)aom_malloc(sizeof(**y_col_buf) * (luma_subblock_size + 2) * 2);
+  *cb_col_buf =
+      (int *)aom_malloc(sizeof(**cb_col_buf) * (chroma_subblock_size + 1));
+  *cr_col_buf =
+      (int *)aom_malloc(sizeof(**cr_col_buf) * (chroma_subblock_size + 1));
+
+  *luma_grain_block =
+      (int *)aom_malloc(sizeof(**luma_grain_block) * luma_grain_samples);
+  *cb_grain_block =
+      (int *)aom_malloc(sizeof(**cb_grain_block) * chroma_grain_samples);
+  *cr_grain_block =
+      (int *)aom_malloc(sizeof(**cr_grain_block) * chroma_grain_samples);
+}
+
+static void dealloc_arrays(aom_film_grain_t *params, int ***pred_pos_luma,
+                           int ***pred_pos_chroma, int **luma_grain_block,
+                           int **cb_grain_block, int **cr_grain_block,
+                           int **y_line_buf, int **cb_line_buf,
+                           int **cr_line_buf, int **y_col_buf, int **cb_col_buf,
+                           int **cr_col_buf) {
+  int num_pos_luma = 2 * params->ar_coeff_lag * (params->ar_coeff_lag + 1);
+  int num_pos_chroma = num_pos_luma + 1;
+
+  for (int row = 0; row < num_pos_luma; row++) {
+    aom_free((*pred_pos_luma)[row]);
+  }
+  aom_free(*pred_pos_luma);
+
+  for (int row = 0; row < num_pos_chroma; row++) {
+    aom_free((*pred_pos_chroma)[row]);
+  }
+  aom_free((*pred_pos_chroma));
+
+  aom_free(*y_line_buf);
+
+  aom_free(*cb_line_buf);
+
+  aom_free(*cr_line_buf);
+
+  aom_free(*y_col_buf);
+
+  aom_free(*cb_col_buf);
+
+  aom_free(*cr_col_buf);
+
+  aom_free(*luma_grain_block);
+
+  aom_free(*cb_grain_block);
+
+  aom_free(*cr_grain_block);
+}
+
+// get a number between 0 and 2^bits - 1
+int get_random_number(int bits) {
+  uint16_t bit;
+  bit = ((random_register >> 0) ^ (random_register >> 1) ^
+         (random_register >> 3) ^ (random_register >> 12)) &
+        1;
+  random_register = (random_register >> 1) | (bit << 15);
+  return (random_register >> (16 - bits)) & ((1 << bits) - 1);
+}
+
+static void init_random_generator(int luma_line, uint16_t seed) {
+  // same for the picture
+
+  uint16_t msb = (seed >> 8) & 255;
+  uint16_t lsb = seed & 255;
+
+  random_register = (msb << 8) + lsb;
+
+  //  changes for each row
+  int luma_num = luma_line >> 5;
+
+  random_register ^= ((luma_num * 37 + 178) & 255) << 8;
+  random_register ^= ((luma_num * 173 + 105) & 255);
+}
+
+static void generate_luma_grain_block(
+    aom_film_grain_t *params, int **pred_pos_luma, int *luma_grain_block,
+    int luma_block_size_y, int luma_block_size_x, int luma_grain_stride,
+    int left_pad, int top_pad, int right_pad, int bottom_pad) {
+  int bit_depth = params->bit_depth;
+
+  int num_pos_luma = 2 * params->ar_coeff_lag * (params->ar_coeff_lag + 1);
+  int rounding_offset = (1 << (params->ar_coeff_shift - 1));
+
+  for (int i = 0; i < luma_block_size_y; i++)
+    for (int j = 0; j < luma_block_size_x; j++)
+      luma_grain_block[i * luma_grain_stride + j] =
+          (gaussian_sequence[get_random_number(gauss_bits)] +
+           ((1 << (12 - bit_depth)) >> 1)) >>
+          (12 - bit_depth);
+
+  for (int i = top_pad; i < luma_block_size_y - bottom_pad; i++)
+    for (int j = left_pad; j < luma_block_size_x - right_pad; j++) {
+      int wsum = 0;
+      for (int pos = 0; pos < num_pos_luma; pos++) {
+        wsum = wsum +
+               params->ar_coeffs_y[pos] *
+                   luma_grain_block[(i + pred_pos_luma[pos][0]) *
+                                        luma_grain_stride +
+                                    j + pred_pos_luma[pos][1]];
+      }
+      luma_grain_block[i * luma_grain_stride + j] =
+          clamp(luma_grain_block[i * luma_grain_stride + j] +
+                    ((wsum + rounding_offset) >> params->ar_coeff_shift),
+                grain_min, grain_max);
+    }
+}
+
+static void generate_chroma_grain_blocks(
+    aom_film_grain_t *params,
+    //                                  int** pred_pos_luma,
+    int **pred_pos_chroma, int *luma_grain_block, int *cb_grain_block,
+    int *cr_grain_block, int luma_grain_stride, int chroma_block_size_y,
+    int chroma_block_size_x, int chroma_grain_stride, int left_pad, int top_pad,
+    int right_pad, int bottom_pad) {
+  int bit_depth = params->bit_depth;
+
+  int num_pos_chroma =
+      2 * params->ar_coeff_lag * (params->ar_coeff_lag + 1) + 1;
+  int rounding_offset = (1 << (params->ar_coeff_shift - 1));
+
+  for (int i = 0; i < chroma_block_size_y; i++)
+    for (int j = 0; j < chroma_block_size_x; j++) {
+      cb_grain_block[i * chroma_grain_stride + j] =
+          (gaussian_sequence[get_random_number(gauss_bits)] +
+           ((1 << (12 - bit_depth)) >> 1)) >>
+          (12 - bit_depth);
+      cr_grain_block[i * chroma_grain_stride + j] =
+          (gaussian_sequence[get_random_number(gauss_bits)] +
+           ((1 << (12 - bit_depth)) >> 1)) >>
+          (12 - bit_depth);
+    }
+
+  for (int i = top_pad; i < chroma_block_size_y - bottom_pad; i++)
+    for (int j = left_pad; j < chroma_block_size_x - right_pad; j++) {
+      int wsum_cb = 0;
+      int wsum_cr = 0;
+      for (int pos = 0; pos < num_pos_chroma; pos++) {
+        if (pred_pos_chroma[pos][2] == 0) {
+          wsum_cb = wsum_cb +
+                    params->ar_coeffs_cb[pos] *
+                        cb_grain_block[(i + pred_pos_chroma[pos][0]) *
+                                           chroma_grain_stride +
+                                       j + pred_pos_chroma[pos][1]];
+          wsum_cr = wsum_cr +
+                    params->ar_coeffs_cr[pos] *
+                        cr_grain_block[(i + pred_pos_chroma[pos][0]) *
+                                           chroma_grain_stride +
+                                       j + pred_pos_chroma[pos][1]];
+        } else if (pred_pos_chroma[pos][2] == 1) {
+          int av_luma =
+              (luma_grain_block[(((i - top_pad) << 1) + top_pad) *
+                                    luma_grain_stride +
+                                ((j - left_pad) << 1) + left_pad] +
+               luma_grain_block[(((i - top_pad) << 1) + top_pad + 1) *
+                                    luma_grain_stride +
+                                ((j - left_pad) << 1) + left_pad] +
+               luma_grain_block[(((i - top_pad) << 1) + top_pad) *
+                                    luma_grain_stride +
+                                ((j - left_pad) << 1) + left_pad + 1] +
+               luma_grain_block[(((i - top_pad) << 1) + top_pad + 1) *
+                                    luma_grain_stride +
+                                ((j - left_pad) << 1) + left_pad + 1] +
+               2) >>
+              2;
+
+          wsum_cb = wsum_cb + params->ar_coeffs_cb[pos] * av_luma;
+          wsum_cr = wsum_cr + params->ar_coeffs_cr[pos] * av_luma;
+        } else {
+          printf(
+              "Grain synthesis: prediction between two chroma components is "
+              "not supported!");
+          exit(1);
+        }
+      }
+      cb_grain_block[i * chroma_grain_stride + j] =
+          clamp(cb_grain_block[i * chroma_grain_stride + j] +
+                    ((wsum_cb + rounding_offset) >> params->ar_coeff_shift),
+                grain_min, grain_max);
+      cr_grain_block[i * chroma_grain_stride + j] =
+          clamp(cr_grain_block[i * chroma_grain_stride + j] +
+                    ((wsum_cr + rounding_offset) >> params->ar_coeff_shift),
+                grain_min, grain_max);
+    }
+}
+
+static void init_scaling_function(int scaling_points[][2], int num_points,
+                                  int scaling_lut[]) {
+  for (int i = 0; i < scaling_points[0][0]; i++)
+    scaling_lut[i] = scaling_points[0][1];
+
+  for (int point = 0; point < num_points - 1; point++) {
+    int delta_y = scaling_points[point + 1][1] - scaling_points[point][1];
+    int delta_x = scaling_points[point + 1][0] - scaling_points[point][0];
+
+    int64_t delta = delta_y * ((65536 + (delta_x >> 1)) / delta_x);
+
+    for (int x = 0; x < delta_x; x++) {
+      scaling_lut[scaling_points[point][0] + x] =
+          scaling_points[point][1] + (int)((x * delta + 32768) >> 16);
+    }
+  }
+
+  for (int i = scaling_points[num_points - 1][0]; i < 256; i++)
+    scaling_lut[i] = scaling_points[num_points - 1][1];
+}
+
+// function that extracts samples from a LUT (and interpolates intemediate
+// frames for 10 bit video)
+static int scale_LUT(int *scaling_lut, int index, int bit_depth) {
+  int x = index >> (bit_depth - 8);
+
+  if (!(bit_depth - 8) || x >= 255)
+    return scaling_lut[x];
+  else
+    return scaling_lut[x] +
+           (((scaling_lut[x + 1] - scaling_lut[x]) * (index & 3) + 2) >> 2);
+}
+
+static void add_noise_to_block(aom_film_grain_t *params, uint8_t *luma,
+                               uint8_t *cb, uint8_t *cr, int luma_stride,
+                               int chroma_stride, int *luma_grain,
+                               int *cb_grain, int *cr_grain,
+                               int luma_grain_stride, int chroma_grain_stride,
+                               int chroma_height, int chroma_width,
+                               int bit_depth) {
+  int cb_mult = params->cb_mult - 128;            // fixed scale
+  int cb_luma_mult = params->cb_luma_mult - 128;  // fixed scale
+  int cb_offset = params->cb_offset - 256;
+
+  int cr_mult = params->cr_mult - 128;            // fixed scale
+  int cr_luma_mult = params->cr_luma_mult - 128;  // fixed scale
+  int cr_offset = params->cr_offset - 256;
+
+  int rounding_offset = (1 << (params->scaling_shift - 1));
+
+  if (params->chroma_scaling_from_luma) {
+    cb_mult = 0;        // fixed scale
+    cb_luma_mult = 64;  // fixed scale
+    cb_offset = 0;
+
+    cr_mult = 0;        // fixed scale
+    cr_luma_mult = 64;  // fixed scale
+    cr_offset = 0;
+  }
+
+  int min_luma, max_luma, min_chroma, max_chroma;
+
+  if (params->clip_to_restricted_range) {
+    min_luma = min_luma_legal_range;
+    max_luma = max_luma_legal_range;
+
+    min_chroma = min_chroma_legal_range;
+    max_chroma = max_chroma_legal_range;
+  } else {
+    min_luma = min_chroma = 0;
+    max_luma = max_chroma = 255;
+  }
+
+  for (int i = 0; i < chroma_height; i++) {
+    for (int j = 0; j < chroma_width; j++) {
+      int average_luma = (luma[(i << 1) * luma_stride + (j << 1)] +
+                          luma[((i << 1)) * luma_stride + (j << 1) + 1] + 1) >>
+                         1;
+
+      luma[((i) << 1) * luma_stride + ((j) << 1)] = clamp(
+          luma[((i) << 1) * luma_stride + ((j) << 1)] +
+              ((scale_LUT(scaling_lut_y,
+                          luma[((i) << 1) * luma_stride + ((j) << 1)], 8) *
+                    luma_grain[(i << 1) * luma_grain_stride + (j << 1)] +
+                rounding_offset) >>
+               params->scaling_shift),
+          min_luma, max_luma);
+      luma[(((i) << 1) + 1) * luma_stride + ((j) << 1)] = clamp(
+          luma[(((i) << 1) + 1) * luma_stride + ((j) << 1)] +
+              ((scale_LUT(scaling_lut_y,
+                          luma[(((i) << 1) + 1) * luma_stride + ((j) << 1)],
+                          8) *
+                    luma_grain[((i << 1) + 1) * luma_grain_stride + (j << 1)] +
+                rounding_offset) >>
+               params->scaling_shift),
+          min_luma, max_luma);
+      luma[(((i) << 1)) * luma_stride + ((j) << 1) + 1] = clamp(
+          luma[(((i) << 1)) * luma_stride + ((j) << 1) + 1] +
+              ((scale_LUT(scaling_lut_y,
+                          luma[(((i) << 1)) * luma_stride + ((j) << 1) + 1],
+                          8) *
+                    luma_grain[(i << 1) * luma_grain_stride + (j << 1) + 1] +
+                rounding_offset) >>
+               params->scaling_shift),
+          min_luma, max_luma);
+      luma[(((i) << 1) + 1) * luma_stride + ((j) << 1) + 1] = clamp(
+          luma[(((i) << 1) + 1) * luma_stride + ((j) << 1) + 1] +
+              ((scale_LUT(scaling_lut_y,
+                          luma[(((i) << 1) + 1) * luma_stride + ((j) << 1) + 1],
+                          8) *
+                    luma_grain[((i << 1) + 1) * luma_grain_stride + (j << 1) +
+                               1] +
+                rounding_offset) >>
+               params->scaling_shift),
+          min_luma, max_luma);
+
+      cb[i * chroma_stride + j] =
+          clamp(cb[i * chroma_stride + j] +
+                    ((scale_LUT(scaling_lut_cb,
+                                clamp(((average_luma * cb_luma_mult +
+                                        cb_mult * cb[i * chroma_stride + j]) >>
+                                       6) +
+                                          cb_offset,
+                                      0, (256 << (bit_depth - 8)) - 1),
+                                8) *
+                          cb_grain[i * chroma_grain_stride + j] +
+                      rounding_offset) >>
+                     params->scaling_shift),
+                min_chroma, max_chroma);
+
+      cr[i * chroma_stride + j] =
+          clamp(cr[i * chroma_stride + j] +
+                    ((scale_LUT(scaling_lut_cr,
+                                clamp(((average_luma * cr_luma_mult +
+                                        cr_mult * cr[i * chroma_stride + j]) >>
+                                       6) +
+                                          cr_offset,
+                                      0, (256 << (bit_depth - 8)) - 1),
+                                8) *
+                          cr_grain[i * chroma_grain_stride + j] +
+                      rounding_offset) >>
+                     params->scaling_shift),
+                min_chroma, max_chroma);
+    }
+  }
+}
+
+static void add_noise_to_block_hbd(aom_film_grain_t *params, uint16_t *luma,
+                                   uint16_t *cb, uint16_t *cr, int luma_stride,
+                                   int chroma_stride, int *luma_grain,
+                                   int *cb_grain, int *cr_grain,
+                                   int luma_grain_stride,
+                                   int chroma_grain_stride, int chroma_height,
+                                   int chroma_width, int bit_depth) {
+  int cb_mult = params->cb_mult - 128;            // fixed scale
+  int cb_luma_mult = params->cb_luma_mult - 128;  // fixed scale
+  // offset value depends on the bit depth
+  int cb_offset = (params->cb_offset << (bit_depth - 8)) - (1 << bit_depth);
+
+  int cr_mult = params->cr_mult - 128;            // fixed scale
+  int cr_luma_mult = params->cr_luma_mult - 128;  // fixed scale
+  // offset value depends on the bit depth
+  int cr_offset = (params->cr_offset << (bit_depth - 8)) - (1 << bit_depth);
+
+  int rounding_offset = (1 << (params->scaling_shift - 1));
+
+  if (params->chroma_scaling_from_luma) {
+    cb_mult = 0;        // fixed scale
+    cb_luma_mult = 64;  // fixed scale
+    cb_offset = 0;
+
+    cr_mult = 0;        // fixed scale
+    cr_luma_mult = 64;  // fixed scale
+    cr_offset = 0;
+  }
+
+  int min_luma, max_luma, min_chroma, max_chroma;
+
+  if (params->clip_to_restricted_range) {
+    min_luma = min_luma_legal_range << (bit_depth - 8);
+    max_luma = max_luma_legal_range << (bit_depth - 8);
+
+    min_chroma = min_chroma_legal_range << (bit_depth - 8);
+    max_chroma = max_chroma_legal_range << (bit_depth - 8);
+  } else {
+    min_luma = min_chroma = 0;
+    max_luma = max_chroma = (256 << (bit_depth - 8)) - 1;
+  }
+
+  for (int i = 0; i < chroma_height; i++) {
+    for (int j = 0; j < chroma_width; j++) {
+      int average_luma = (luma[(i << 1) * luma_stride + (j << 1)] +
+                          luma[((i << 1)) * luma_stride + (j << 1) + 1] + 1) >>
+                         1;
+
+      luma[((i) << 1) * luma_stride + ((j) << 1)] =
+          clamp(luma[((i) << 1) * luma_stride + ((j) << 1)] +
+                    ((scale_LUT(scaling_lut_y,
+                                luma[((i) << 1) * luma_stride + ((j) << 1)],
+                                bit_depth) *
+                          luma_grain[(i << 1) * luma_grain_stride + (j << 1)] +
+                      rounding_offset) >>
+                     params->scaling_shift),
+                min_luma, max_luma);
+      luma[(((i) << 1) + 1) * luma_stride + ((j) << 1)] = clamp(
+          luma[(((i) << 1) + 1) * luma_stride + ((j) << 1)] +
+              ((scale_LUT(scaling_lut_y,
+                          luma[(((i) << 1) + 1) * luma_stride + ((j) << 1)],
+                          bit_depth) *
+                    luma_grain[((i << 1) + 1) * luma_grain_stride + (j << 1)] +
+                rounding_offset) >>
+               params->scaling_shift),
+          min_luma, max_luma);
+      luma[(((i) << 1)) * luma_stride + ((j) << 1) + 1] = clamp(
+          luma[(((i) << 1)) * luma_stride + ((j) << 1) + 1] +
+              ((scale_LUT(scaling_lut_y,
+                          luma[(((i) << 1)) * luma_stride + ((j) << 1) + 1],
+                          bit_depth) *
+                    luma_grain[(i << 1) * luma_grain_stride + (j << 1) + 1] +
+                rounding_offset) >>
+               params->scaling_shift),
+          min_luma, max_luma);
+      luma[(((i) << 1) + 1) * luma_stride + ((j) << 1) + 1] = clamp(
+          luma[(((i) << 1) + 1) * luma_stride + ((j) << 1) + 1] +
+              ((scale_LUT(scaling_lut_y,
+                          luma[(((i) << 1) + 1) * luma_stride + ((j) << 1) + 1],
+                          bit_depth) *
+                    luma_grain[((i << 1) + 1) * luma_grain_stride + (j << 1) +
+                               1] +
+                rounding_offset) >>
+               params->scaling_shift),
+          min_luma, max_luma);
+
+      cb[i * chroma_stride + j] =
+          clamp(cb[i * chroma_stride + j] +
+                    ((scale_LUT(scaling_lut_cb,
+                                clamp(((average_luma * cb_luma_mult +
+                                        cb_mult * cb[i * chroma_stride + j]) >>
+                                       6) +
+                                          cb_offset,
+                                      0, (256 << (bit_depth - 8)) - 1),
+                                bit_depth) *
+                          cb_grain[i * chroma_grain_stride + j] +
+                      rounding_offset) >>
+                     params->scaling_shift),
+                min_chroma, max_chroma);
+
+      cr[i * chroma_stride + j] =
+          clamp(cr[i * chroma_stride + j] +
+                    ((scale_LUT(scaling_lut_cr,
+                                clamp(((average_luma * cr_luma_mult +
+                                        cr_mult * cr[i * chroma_stride + j]) >>
+                                       6) +
+                                          cr_offset,
+                                      0, (256 << (bit_depth - 8)) - 1),
+                                bit_depth) *
+                          cr_grain[i * chroma_grain_stride + j] +
+                      rounding_offset) >>
+                     params->scaling_shift),
+                min_chroma, max_chroma);
+    }
+  }
+}
+
+static void copy_rect(uint8_t *src, int src_stride, uint8_t *dst,
+                      int dst_stride, int width, int height,
+                      int high_bit_depth) {
+  int hbd_coeff = high_bit_depth ? 2 : 0;
+  while (height) {
+    memcpy(dst, src, width * sizeof(uint8_t) * hbd_coeff);
+    src += src_stride;
+    dst += dst_stride;
+    --height;
+  }
+  return;
+}
+
+void av1_add_film_grain(aom_film_grain_t *params, aom_image_t *src,
+                        aom_image_t *dst) {
+  uint8_t *luma, *cb, *cr;
+  int height, width, luma_stride, chroma_stride;
+
+  if (!(src->fmt == AOM_IMG_FMT_I42016) && !(src->fmt == AOM_IMG_FMT_I420)) {
+    printf("Film grain error: only 4:2:0 is currently supported!");
+    exit(1);
+  }
+
+  dst->r_w = src->r_w;
+  dst->r_h = src->r_h;
+
+  copy_rect(src->planes[AOM_PLANE_Y], src->stride[AOM_PLANE_Y],
+            dst->planes[AOM_PLANE_Y], dst->stride[AOM_PLANE_Y], dst->d_w,
+            dst->d_h, src->bit_depth);
+
+  copy_rect(src->planes[AOM_PLANE_U], src->stride[AOM_PLANE_U],
+            dst->planes[AOM_PLANE_U], dst->stride[AOM_PLANE_U], dst->d_w / 2,
+            dst->d_h / 2, src->bit_depth);
+
+  copy_rect(src->planes[AOM_PLANE_V], src->stride[AOM_PLANE_V],
+            dst->planes[AOM_PLANE_V], dst->stride[AOM_PLANE_V], dst->d_w / 2,
+            dst->d_h / 2, src->bit_depth);
+
+  luma = dst->planes[AOM_PLANE_Y];
+  cb = dst->planes[AOM_PLANE_U];
+  cr = dst->planes[AOM_PLANE_V];
+  luma_stride = (dst->fmt == AOM_IMG_FMT_I42016) ? dst->stride[AOM_PLANE_Y] / 2
+                                                 : dst->stride[AOM_PLANE_Y];
+  chroma_stride = (dst->fmt == AOM_IMG_FMT_I42016)
+                      ? dst->stride[AOM_PLANE_U] / 2
+                      : dst->stride[AOM_PLANE_U];
+  width = dst->d_w;
+  height = dst->d_h;
+  params->bit_depth = dst->bit_depth;
+
+  int use_high_bit_depth = 0;
+
+  if (dst->fmt == AOM_IMG_FMT_I42016) {
+    use_high_bit_depth = 1;
+  }
+
+  av1_add_film_grain_run(params, luma, cb, cr, height, width, luma_stride,
+                         chroma_stride, use_high_bit_depth);
+  return;
+}
+
+void av1_add_film_grain_run(aom_film_grain_t *params, uint8_t *luma,
+                            uint8_t *cb, uint8_t *cr, int height, int width,
+                            int luma_stride, int chroma_stride,
+                            int use_high_bit_depth) {
+  int **pred_pos_luma;
+  int **pred_pos_chroma;
+  int *luma_grain_block;
+  int *cb_grain_block;
+  int *cr_grain_block;
+
+  int *y_line_buf;
+  int *cb_line_buf;
+  int *cr_line_buf;
+
+  int *y_col_buf;
+  int *cb_col_buf;
+  int *cr_col_buf;
+
+  random_register = params->random_seed;
+
+  int left_pad = 3;
+  int right_pad = 3;  // padding to offset for AR coefficients
+  int top_pad = 3;
+  int bottom_pad = 0;
+
+  int ar_padding = 3;  // maximum lag used for stabilization of AR coefficients
+
+  // Initial padding is only needed for generation of
+  // film grain templates (to stabilize the AR process)
+  // Only a 64x64 luma and 32x32 chroma part of a template
+  // is used later for adding grain, padding can be discarded
+
+  int luma_block_size_y =
+      top_pad + 2 * ar_padding + luma_subblock_size * 2 + bottom_pad;
+  int luma_block_size_x = left_pad + 2 * ar_padding + luma_subblock_size * 2 +
+                          2 * ar_padding + right_pad;
+
+  int chroma_block_size_y =
+      top_pad + ar_padding + chroma_subblock_size * 2 + bottom_pad;
+  int chroma_block_size_x =
+      left_pad + ar_padding + chroma_subblock_size * 2 + ar_padding + right_pad;
+
+  int luma_grain_stride = luma_block_size_x;
+  int chroma_grain_stride = chroma_block_size_x;
+
+  int overlap = params->overlap_flag;
+  int bit_depth = params->bit_depth;
+
+  grain_center = 128 << (bit_depth - 8);
+  grain_min = 0 - grain_center;
+  grain_max = (256 << (bit_depth - 8)) - 1 - grain_center;
+
+  init_arrays(params, luma_stride, chroma_stride, &pred_pos_luma,
+              &pred_pos_chroma, &luma_grain_block, &cb_grain_block,
+              &cr_grain_block, &y_line_buf, &cb_line_buf, &cr_line_buf,
+              &y_col_buf, &cb_col_buf, &cr_col_buf,
+              luma_block_size_y * luma_block_size_x,
+              chroma_block_size_y * chroma_block_size_x);
+
+  generate_luma_grain_block(params, pred_pos_luma, luma_grain_block,
+                            luma_block_size_y, luma_block_size_x,
+                            luma_grain_stride, left_pad, top_pad, right_pad,
+                            bottom_pad);
+
+  generate_chroma_grain_blocks(
+      params,
+      //                               pred_pos_luma,
+      pred_pos_chroma, luma_grain_block, cb_grain_block, cr_grain_block,
+      luma_grain_stride, chroma_block_size_y, chroma_block_size_x,
+      chroma_grain_stride, left_pad, top_pad, right_pad, bottom_pad);
+
+  init_scaling_function(params->scaling_points_y, params->num_y_points,
+                        scaling_lut_y);
+
+  if (params->chroma_scaling_from_luma) {
+    memcpy(scaling_lut_cb, scaling_lut_y, sizeof(*scaling_lut_y) * 256);
+    memcpy(scaling_lut_cr, scaling_lut_y, sizeof(*scaling_lut_y) * 256);
+  } else {
+    init_scaling_function(params->scaling_points_cb, params->num_cb_points,
+                          scaling_lut_cb);
+    init_scaling_function(params->scaling_points_cr, params->num_cr_points,
+                          scaling_lut_cr);
+  }
+  for (int y = 0; y < height / 2; y += chroma_subblock_size) {
+    init_random_generator(y * 2, params->random_seed);
+
+    for (int x = 0; x < width / 2; x += chroma_subblock_size) {
+      int offset_y = get_random_number(8);
+      int offset_x = (offset_y >> 4) & 15;
+      offset_y &= 15;
+
+      int luma_offset_y = left_pad + 2 * ar_padding + (offset_y << 1);
+      int luma_offset_x = top_pad + 2 * ar_padding + (offset_x << 1);
+
+      int chroma_offset_y = top_pad + ar_padding + offset_y;
+      int chroma_offset_x = left_pad + ar_padding + offset_x;
+
+      if (overlap && x) {
+        for (int i = 0; i < AOMMIN(chroma_subblock_size, height / 2 - y); i++) {
+          y_col_buf[(i << 1) * 2] =
+              clamp((27 * y_col_buf[(i << 1) * 2] +
+                     17 * luma_grain_block[(luma_offset_y + (i << 1)) *
+                                               luma_grain_stride +
+                                           luma_offset_x] +
+                     16) >>
+                        5,
+                    grain_min, grain_max);
+
+          y_col_buf[(i << 1) * 2 + 1] =
+              clamp((17 * y_col_buf[(i << 1) * 2 + 1] +
+                     27 * luma_grain_block[(luma_offset_y + (i << 1)) *
+                                               luma_grain_stride +
+                                           luma_offset_x + 1] +
+                     16) >>
+                        5,
+                    grain_min, grain_max);
+
+          y_col_buf[(i << 1) * 2 + 2] =
+              clamp((27 * y_col_buf[(i << 1) * 2 + 2] +
+                     17 * luma_grain_block[(luma_offset_y + (i << 1) + 1) *
+                                               luma_grain_stride +
+                                           luma_offset_x] +
+                     16) >>
+                        5,
+                    grain_min, grain_max);
+          y_col_buf[(i << 1) * 2 + 3] =
+              clamp((17 * y_col_buf[(i << 1) * 2 + 3] +
+                     27 * luma_grain_block[(luma_offset_y + (i << 1) + 1) *
+                                               luma_grain_stride +
+                                           luma_offset_x + 1] +
+                     16) >>
+                        5,
+                    grain_min, grain_max);
+
+          cb_col_buf[i] = clamp(
+              (23 * cb_col_buf[i] +
+               22 * cb_grain_block[(chroma_offset_y + i) * chroma_grain_stride +
+                                   chroma_offset_x] +
+               16) >>
+                  5,
+              grain_min, grain_max);
+          cr_col_buf[i] = clamp(
+              (23 * cr_col_buf[i] +
+               22 * cr_grain_block[(chroma_offset_y + i) * chroma_grain_stride +
+                                   chroma_offset_x] +
+               16) >>
+                  5,
+              grain_min, grain_max);
+        }
+
+        int i = y ? 1 : 0;
+
+        if (use_high_bit_depth) {
+          add_noise_to_block_hbd(
+              params,
+              (uint16_t *)luma + ((y + i) << 1) * luma_stride + (x << 1),
+              (uint16_t *)cb + (y + i) * chroma_stride + x,
+              (uint16_t *)cr + (y + i) * chroma_stride + x, luma_stride,
+              chroma_stride, y_col_buf + i * 4, cb_col_buf + i, cr_col_buf + i,
+              2, 1, AOMMIN(chroma_subblock_size, height / 2 - y) - i, 1,
+              bit_depth);
+        } else {
+          add_noise_to_block(
+              params, luma + ((y + i) << 1) * luma_stride + (x << 1),
+              cb + (y + i) * chroma_stride + x,
+              cr + (y + i) * chroma_stride + x, luma_stride, chroma_stride,
+              y_col_buf + i * 4, cb_col_buf + i, cr_col_buf + i, 2, 1,
+              AOMMIN(chroma_subblock_size, height / 2 - y) - i, 1, bit_depth);
+        }
+      }
+
+      if (overlap && y) {
+        if (x) {
+          y_line_buf[x << 1] =
+              clamp((17 * y_col_buf[0] + 27 * y_line_buf[x << 1] + 16) >> 5,
+                    grain_min, grain_max);
+          y_line_buf[(x << 1) + 1] = clamp(
+              (17 * y_col_buf[1] + 27 * y_line_buf[(x << 1) + 1] + 16) >> 5,
+              grain_min, grain_max);
+          y_line_buf[luma_stride + (x << 1)] =
+              clamp((27 * y_col_buf[2] +
+                     17 * y_line_buf[luma_stride + (x << 1)] + 16) >>
+                        5,
+                    grain_min, grain_max);
+          y_line_buf[luma_stride + (x << 1) + 1] =
+              clamp((27 * y_col_buf[3] +
+                     17 * y_line_buf[luma_stride + (x << 1) + 1] + 16) >>
+                        5,
+                    grain_min, grain_max);
+
+          cb_line_buf[x] =
+              clamp((22 * cb_col_buf[0] + 23 * cb_line_buf[x] + 16) >> 5,
+                    grain_min, grain_max);
+          cr_line_buf[x] =
+              clamp((22 * cr_col_buf[0] + 23 * cr_line_buf[x] + 16) >> 5,
+                    grain_min, grain_max);
+        }
+
+        for (int j = x ? 1 : 0; j < AOMMIN(chroma_subblock_size, width / 2 - x);
+             j++) {
+          y_line_buf[(x + j) << 1] =
+              clamp((27 * y_line_buf[(x + j) << 1] +
+                     17 * luma_grain_block[luma_offset_y * luma_grain_stride +
+                                           luma_offset_x + (j << 1)] +
+                     16) >>
+                        5,
+                    grain_min, grain_max);
+          y_line_buf[((x + j) << 1) + 1] =
+              clamp((27 * y_line_buf[((x + j) << 1) + 1] +
+                     17 * luma_grain_block[luma_offset_y * luma_grain_stride +
+                                           luma_offset_x + (j << 1) + 1] +
+                     16) >>
+                        5,
+                    grain_min, grain_max);
+
+          y_line_buf[luma_stride + ((x + j) << 1)] = clamp(
+              (17 * y_line_buf[luma_stride + ((x + j) << 1)] +
+               27 * luma_grain_block[(luma_offset_y + 1) * luma_grain_stride +
+                                     luma_offset_x + (j << 1)] +
+               16) >>
+                  5,
+              grain_min, grain_max);
+          y_line_buf[luma_stride + ((x + j) << 1) + 1] = clamp(
+              (17 * y_line_buf[luma_stride + ((x + j) << 1) + 1] +
+               27 * luma_grain_block[(luma_offset_y + 1) * luma_grain_stride +
+                                     luma_offset_x + (j << 1) + 1] +
+               16) >>
+                  5,
+              grain_min, grain_max);
+
+          cb_line_buf[x + j] =
+              clamp((23 * cb_line_buf[x + j] +
+                     22 * cb_grain_block[chroma_offset_y * chroma_grain_stride +
+                                         chroma_offset_x + j] +
+                     16) >>
+                        5,
+                    grain_min, grain_max);
+          cr_line_buf[x + j] =
+              clamp((23 * cr_line_buf[x + j] +
+                     22 * cr_grain_block[chroma_offset_y * chroma_grain_stride +
+                                         chroma_offset_x + j] +
+                     16) >>
+                        5,
+                    grain_min, grain_max);
+        }
+
+        if (use_high_bit_depth) {
+          add_noise_to_block_hbd(
+              params, (uint16_t *)luma + (y << 1) * luma_stride + (x << 1),
+              (uint16_t *)cb + y * chroma_stride + x,
+              (uint16_t *)cr + y * chroma_stride + x, luma_stride,
+              chroma_stride, y_line_buf + (x << 1), cb_line_buf + x,
+              cr_line_buf + x, luma_stride, chroma_stride, 1,
+              AOMMIN(chroma_subblock_size, width / 2 - x), bit_depth);
+        } else {
+          add_noise_to_block(
+              params, luma + (y << 1) * luma_stride + (x << 1),
+              cb + y * chroma_stride + x, cr + y * chroma_stride + x,
+              luma_stride, chroma_stride, y_line_buf + (x << 1),
+              cb_line_buf + x, cr_line_buf + x, luma_stride, chroma_stride, 1,
+              AOMMIN(chroma_subblock_size, width / 2 - x), bit_depth);
+        }
+      }
+
+      int i = overlap && y ? 1 : 0;
+      int j = overlap && x ? 1 : 0;
+
+      if (use_high_bit_depth) {
+        add_noise_to_block_hbd(
+            params,
+            (uint16_t *)luma + ((y + i) << 1) * luma_stride + ((x + j) << 1),
+            (uint16_t *)cb + (y + i) * chroma_stride + x + j,
+            (uint16_t *)cr + (y + i) * chroma_stride + x + j, luma_stride,
+            chroma_stride,
+            luma_grain_block + (luma_offset_y + (i << 1)) * luma_grain_stride +
+                luma_offset_x + (j << 1),
+            cb_grain_block + (chroma_offset_y + i) * chroma_grain_stride +
+                chroma_offset_x + j,
+            cr_grain_block + (chroma_offset_y + i) * chroma_grain_stride +
+                chroma_offset_x + j,
+            luma_grain_stride, chroma_grain_stride,
+            AOMMIN(chroma_subblock_size, height / 2 - y) - i,
+            AOMMIN(chroma_subblock_size, width / 2 - x) - j, bit_depth);
+      } else {
+        add_noise_to_block(
+            params, luma + ((y + i) << 1) * luma_stride + ((x + j) << 1),
+            cb + (y + i) * chroma_stride + x + j,
+            cr + (y + i) * chroma_stride + x + j, luma_stride, chroma_stride,
+            luma_grain_block + (luma_offset_y + (i << 1)) * luma_grain_stride +
+                luma_offset_x + (j << 1),
+            cb_grain_block + (chroma_offset_y + i) * chroma_grain_stride +
+                chroma_offset_x + j,
+            cr_grain_block + (chroma_offset_y + i) * chroma_grain_stride +
+                chroma_offset_x + j,
+            luma_grain_stride, chroma_grain_stride,
+            AOMMIN(chroma_subblock_size, height / 2 - y) - i,
+            AOMMIN(chroma_subblock_size, width / 2 - x) - j, bit_depth);
+      }
+
+      if (overlap) {
+        if (x) {
+          y_line_buf[x << 1] = clamp(
+              (27 * y_line_buf[x << 1] +
+               17 * luma_grain_block[(luma_offset_y + luma_subblock_size) *
+                                         luma_grain_stride +
+                                     luma_offset_x] +
+               16) >>
+                  5,
+              grain_min, grain_max);
+          y_line_buf[(x << 1) + 1] = clamp(
+              (17 * y_line_buf[(x << 1) + 1] +
+               27 * luma_grain_block[(luma_offset_y + luma_subblock_size) *
+                                         luma_grain_stride +
+                                     luma_offset_x + 1] +
+               16) >>
+                  5,
+              grain_min, grain_max);
+          y_line_buf[luma_stride + (x << 1)] = clamp(
+              (27 * y_line_buf[luma_stride + (x << 1)] +
+               17 * luma_grain_block[(luma_offset_y + luma_subblock_size + 1) *
+                                         luma_grain_stride +
+                                     luma_offset_x] +
+               16) >>
+                  5,
+              grain_min, grain_max);
+          y_line_buf[luma_stride + (x << 1) + 1] = clamp(
+              (17 * y_line_buf[luma_stride + (x << 1) + 1] +
+               27 * luma_grain_block[(luma_offset_y + luma_subblock_size + 1) *
+                                         luma_grain_stride +
+                                     luma_offset_x + 1] +
+               16) >>
+                  5,
+              grain_min, grain_max);
+
+          cb_line_buf[x] = clamp(
+              (23 * cb_col_buf[x] +
+               22 * cb_grain_block[(chroma_offset_y + chroma_subblock_size) *
+                                       chroma_grain_stride +
+                                   chroma_offset_x] +
+               16) >>
+                  5,
+              grain_min, grain_max);
+          cr_line_buf[x] = clamp(
+              (23 * cr_col_buf[x] +
+               22 * cr_grain_block[(chroma_offset_y + chroma_subblock_size) *
+                                       chroma_grain_stride +
+                                   chroma_offset_x] +
+               16) >>
+                  5,
+              grain_min, grain_max);
+        }
+
+        for (int m = overlap && x ? 1 : 0;
+             m < AOMMIN(chroma_subblock_size + 1, width / 2 - x); m++) {
+          y_line_buf[(x + m) << 1] =
+              luma_grain_block[(luma_offset_y + luma_subblock_size) *
+                                   luma_grain_stride +
+                               luma_offset_x + (m << 1)];
+          y_line_buf[((x + m) << 1) + 1] =
+              luma_grain_block[(luma_offset_y + luma_subblock_size) *
+                                   luma_grain_stride +
+                               luma_offset_x + (m << 1) + 1];
+          y_line_buf[luma_stride + ((x + m) << 1)] =
+              luma_grain_block[(luma_offset_y + luma_subblock_size + 1) *
+                                   luma_grain_stride +
+                               luma_offset_x + (m << 1)];
+          y_line_buf[luma_stride + ((x + m) << 1) + 1] =
+              luma_grain_block[(luma_offset_y + luma_subblock_size + 1) *
+                                   luma_grain_stride +
+                               luma_offset_x + (m << 1) + 1];
+
+          cb_line_buf[x + m] =
+              cb_grain_block[(chroma_offset_y + chroma_subblock_size) *
+                                 chroma_grain_stride +
+                             chroma_offset_x + m];
+          cr_line_buf[x + m] =
+              cr_grain_block[(chroma_offset_y + chroma_subblock_size) *
+                                 chroma_grain_stride +
+                             chroma_offset_x + m];
+        }
+
+        for (int n = 0; n < AOMMIN(chroma_subblock_size + 1, height / 2 - y);
+             n++) {
+          y_col_buf[(n << 1) * 2] =
+              luma_grain_block[(luma_offset_y + (n << 1)) * luma_grain_stride +
+                               luma_offset_x + luma_subblock_size];
+          y_col_buf[(n << 1) * 2 + 1] =
+              luma_grain_block[(luma_offset_y + (n << 1)) * luma_grain_stride +
+                               luma_offset_x + luma_subblock_size + 1];
+
+          y_col_buf[((n << 1) + 1) * 2] =
+              luma_grain_block[(luma_offset_y + (n << 1) + 1) *
+                                   luma_grain_stride +
+                               luma_offset_x + luma_subblock_size];
+          y_col_buf[((n << 1) + 1) * 2 + 1] =
+              luma_grain_block[(luma_offset_y + (n << 1) + 1) *
+                                   luma_grain_stride +
+                               luma_offset_x + luma_subblock_size + 1];
+
+          cb_col_buf[n] =
+              cb_grain_block[(chroma_offset_y + n) * chroma_grain_stride +
+                             chroma_offset_x + chroma_subblock_size];
+          cr_col_buf[n] =
+              cr_grain_block[(chroma_offset_y + n) * chroma_grain_stride +
+                             chroma_offset_x + chroma_subblock_size];
+        }
+      }
+    }
+  }
+
+  dealloc_arrays(params, &pred_pos_luma, &pred_pos_chroma, &luma_grain_block,
+                 &cb_grain_block, &cr_grain_block, &y_line_buf, &cb_line_buf,
+                 &cr_line_buf, &y_col_buf, &cb_col_buf, &cr_col_buf);
+}
diff --git a/aom_dsp/grain_synthesis.h b/aom_dsp/grain_synthesis.h
new file mode 100644
index 0000000..6bad640
--- /dev/null
+++ b/aom_dsp/grain_synthesis.h
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2016, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 2 Clause License and
+ * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+ * was not distributed with this source code in the LICENSE file, you can
+ * obtain it at www.aomedia.org/license/software. If the Alliance for Open
+ * Media Patent License 1.0 was not distributed with this source code in the
+ * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+ */
+
+/*!\file
+ * \brief Describes film grain parameters and film grain synthesis
+ *
+ */
+#ifndef AOM_AOM_GRAIN_SYNTHESIS_H_
+#define AOM_AOM_GRAIN_SYNTHESIS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "aom_dsp/aom_dsp_common.h"
+#include "aom/aom_image.h"
+
+/*!\brief Structure containing film grain synthesis parameters for a frame
+ *
+ * This structure contains input parameters for film grain synthesis
+ */
+typedef struct {
+  int apply_grain;
+
+  int update_parameters;
+
+  // 8 bit values
+  int scaling_points_y[14][2];
+  int num_y_points;  // value: 0..14
+
+  // 8 bit values
+  int scaling_points_cb[10][2];
+  int num_cb_points;  // value: 0..10
+
+  // 8 bit values
+  int scaling_points_cr[10][2];
+  int num_cr_points;  // value: 0..10
+
+  int scaling_shift;  // values : 8..11
+
+  int ar_coeff_lag;  // values:  0..3
+
+  // 8 bit values
+  int ar_coeffs_y[24];
+  int ar_coeffs_cb[25];
+  int ar_coeffs_cr[25];
+
+  // Shift value: AR coeffs range
+  // 6: [-2, 2)
+  // 7: [-1, 1)
+  // 8: [-0.5, 0.5)
+  // 9: [-0.25, 0.25)
+  int ar_coeff_shift;  // values : 6..9
+
+  int cb_mult;       // 8 bits
+  int cb_luma_mult;  // 8 bits
+  int cb_offset;     // 9 bits
+
+  int cr_mult;       // 8 bits
+  int cr_luma_mult;  // 8 bits
+  int cr_offset;     // 9 bits
+
+  int overlap_flag;
+
+  int clip_to_restricted_range;
+
+  int bit_depth;  // video bit depth
+
+  int chroma_scaling_from_luma;
+
+  uint16_t random_seed;
+} aom_film_grain_t;
+
+/*!\brief Add film grain
+ *
+ * Add film grain to an image
+ *
+ * \param[in]    grain_params     Grain parameters
+ * \param[in]    luma             luma plane
+ * \param[in]    cb               cb plane
+ * \param[in]    cr               cr plane
+ * \param[in]    height           luma plane height
+ * \param[in]    width            luma plane width
+ * \param[in]    luma_stride      luma plane stride
+ * \param[in]    chroma_stride    chroma plane stride
+ */
+void av1_add_film_grain_run(aom_film_grain_t *grain_params, uint8_t *luma,
+                            uint8_t *cb, uint8_t *cr, int height, int width,
+                            int luma_stride, int chroma_stride,
+                            int use_high_bit_depth);
+
+/*!\brief Add film grain
+ *
+ * Add film grain to an image
+ *
+ * \param[in]    grain_params     Grain parameters
+ * \param[in]    src              Source image
+ * \param[in]    dst              Resulting image with grain
+ */
+void av1_add_film_grain(aom_film_grain_t *grain_params, aom_image_t *src,
+                        aom_image_t *dst);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // AOM_AOM_GRAIN_SYNTHESIS_H_