1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "VideoEditorTools.h" 18 #include "PreviewRenderer.h" 19 /*+ Handle the image files here */ 20 #include <utils/Log.h> 21 /*- Handle the image files here */ 22 23 const M4VIFI_UInt8 M4VIFI_ClipTable[1256] 24 = { 25 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 26 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 27 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 28 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 29 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 30 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 31 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 32 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 33 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 34 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 35 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 36 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 37 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 38 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 39 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 40 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 41 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 42 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 43 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 44 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 45 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 46 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 47 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 48 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 49 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 50 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 51 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 52 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 53 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 54 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 55 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 56 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 57 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 58 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 59 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 60 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 61 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 62 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 63 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 64 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 65 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 66 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 67 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 68 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 69 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 70 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 71 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 72 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 73 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 74 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 75 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 76 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 77 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 78 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 79 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 80 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 81 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 82 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 83 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 84 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 85 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 86 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 87 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 88 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 89 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 90 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 91 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 92 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 93 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 94 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 95 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 96 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 97 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 98 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 99 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 100 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 101 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 102 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 103 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 104 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 105 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 106 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 107 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 108 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 109 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 110 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 111 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 112 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 113 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 114 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 115 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 116 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 117 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 118 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 119 0xfc, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 120 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 121 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 122 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 123 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 124 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 125 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 126 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 127 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 128 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 129 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 130 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 131 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 132 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 133 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 134 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 135 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 136 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 137 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 138 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 139 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 140 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 141 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 142 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 143 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 144 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 145 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 146 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 147 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 148 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 149 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 150 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 151 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 152 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 153 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 154 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 155 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 156 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 157 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 158 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 159 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 160 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 161 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 162 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 163 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 164 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 165 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 166 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 167 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 168 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 169 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 170 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 171 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 172 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 173 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 174 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 175 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 176 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 177 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 178 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 179 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 180 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 181 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff 182 }; 183 184 /* Division table for ( 65535/x ); x = 0 to 512 */ 185 const M4VIFI_UInt16 M4VIFI_DivTable[512] 186 = { 187 0, 65535, 32768, 21845, 16384, 13107, 10922, 9362, 188 8192, 7281, 6553, 5957, 5461, 5041, 4681, 4369, 189 4096, 3855, 3640, 3449, 3276, 3120, 2978, 2849, 190 2730, 2621, 2520, 2427, 2340, 2259, 2184, 2114, 191 2048, 1985, 1927, 1872, 1820, 1771, 1724, 1680, 192 1638, 1598, 1560, 1524, 1489, 1456, 1424, 1394, 193 1365, 1337, 1310, 1285, 1260, 1236, 1213, 1191, 194 1170, 1149, 1129, 1110, 1092, 1074, 1057, 1040, 195 1024, 1008, 992, 978, 963, 949, 936, 923, 196 910, 897, 885, 873, 862, 851, 840, 829, 197 819, 809, 799, 789, 780, 771, 762, 753, 198 744, 736, 728, 720, 712, 704, 697, 689, 199 682, 675, 668, 661, 655, 648, 642, 636, 200 630, 624, 618, 612, 606, 601, 595, 590, 201 585, 579, 574, 569, 564, 560, 555, 550, 202 546, 541, 537, 532, 528, 524, 520, 516, 203 512, 508, 504, 500, 496, 492, 489, 485, 204 481, 478, 474, 471, 468, 464, 461, 458, 205 455, 451, 448, 445, 442, 439, 436, 434, 206 431, 428, 425, 422, 420, 417, 414, 412, 207 409, 407, 404, 402, 399, 397, 394, 392, 208 390, 387, 385, 383, 381, 378, 376, 374, 209 372, 370, 368, 366, 364, 362, 360, 358, 210 356, 354, 352, 350, 348, 346, 344, 343, 211 341, 339, 337, 336, 334, 332, 330, 329, 212 327, 326, 324, 322, 321, 319, 318, 316, 213 315, 313, 312, 310, 309, 307, 306, 304, 214 303, 302, 300, 299, 297, 296, 295, 293, 215 292, 291, 289, 288, 287, 286, 284, 283, 216 282, 281, 280, 278, 277, 276, 275, 274, 217 273, 271, 270, 269, 268, 267, 266, 265, 218 264, 263, 262, 261, 260, 259, 258, 257, 219 256, 255, 254, 253, 252, 251, 250, 249, 220 248, 247, 246, 245, 244, 243, 242, 241, 221 240, 240, 239, 238, 237, 236, 235, 234, 222 234, 233, 232, 231, 230, 229, 229, 228, 223 227, 226, 225, 225, 224, 223, 222, 222, 224 221, 220, 219, 219, 218, 217, 217, 216, 225 215, 214, 214, 213, 212, 212, 211, 210, 226 210, 209, 208, 208, 207, 206, 206, 205, 227 204, 204, 203, 202, 202, 201, 201, 200, 228 199, 199, 198, 197, 197, 196, 196, 195, 229 195, 194, 193, 193, 192, 192, 191, 191, 230 190, 189, 189, 188, 188, 187, 187, 186, 231 186, 185, 185, 184, 184, 183, 183, 182, 232 182, 181, 181, 180, 180, 179, 179, 178, 233 178, 177, 177, 176, 176, 175, 175, 174, 234 174, 173, 173, 172, 172, 172, 171, 171, 235 170, 170, 169, 169, 168, 168, 168, 167, 236 167, 166, 166, 165, 165, 165, 164, 164, 237 163, 163, 163, 162, 162, 161, 161, 161, 238 160, 160, 159, 159, 159, 158, 158, 157, 239 157, 157, 156, 156, 156, 155, 155, 154, 240 154, 154, 153, 153, 153, 152, 152, 152, 241 151, 151, 151, 150, 150, 149, 149, 149, 242 148, 148, 148, 147, 147, 147, 146, 146, 243 146, 145, 145, 145, 144, 144, 144, 144, 244 143, 143, 143, 142, 142, 142, 141, 141, 245 141, 140, 140, 140, 140, 139, 139, 139, 246 138, 138, 138, 137, 137, 137, 137, 136, 247 136, 136, 135, 135, 135, 135, 134, 134, 248 134, 134, 133, 133, 133, 132, 132, 132, 249 132, 131, 131, 131, 131, 130, 130, 130, 250 130, 129, 129, 129, 129, 128, 128, 128 251 }; 252 253 const M4VIFI_Int32 const_storage1[8] 254 = { 255 0x00002568, 0x00003343,0x00000649,0x00000d0f, 0x0000D86C, 0x0000D83B, 0x00010000, 0x00010000 256 }; 257 258 const M4VIFI_Int32 const_storage[8] 259 = { 260 0x00002568, 0x00003343, 0x1BF800, 0x00000649, 0x00000d0f, 0x110180, 0x40cf, 0x22BE00 261 }; 262 263 264 const M4VIFI_UInt16 *M4VIFI_DivTable_zero 265 = &M4VIFI_DivTable[0]; 266 267 const M4VIFI_UInt8 *M4VIFI_ClipTable_zero 268 = &M4VIFI_ClipTable[500]; 269 270 M4VIFI_UInt8 M4VIFI_YUV420PlanarToYUV420Semiplanar(void *user_data, 271 M4VIFI_ImagePlane *PlaneIn, M4VIFI_ImagePlane *PlaneOut ) { 272 273 M4VIFI_UInt32 i; 274 M4VIFI_UInt8 *p_buf_src, *p_buf_dest, *p_buf_src_u, *p_buf_src_v; 275 M4VIFI_UInt8 return_code = M4VIFI_OK; 276 277 /* the filter is implemented with the assumption that the width is equal to stride */ 278 if(PlaneIn[0].u_width != PlaneIn[0].u_stride) 279 return M4VIFI_INVALID_PARAM; 280 281 /* The input Y Plane is the same as the output Y Plane */ 282 p_buf_src = &(PlaneIn[0].pac_data[PlaneIn[0].u_topleft]); 283 p_buf_dest = &(PlaneOut[0].pac_data[PlaneOut[0].u_topleft]); 284 memcpy((void *)p_buf_dest,(void *)p_buf_src , 285 PlaneOut[0].u_width * PlaneOut[0].u_height); 286 287 /* The U and V components are planar. The need to be made interleaved */ 288 p_buf_src_u = &(PlaneIn[1].pac_data[PlaneIn[1].u_topleft]); 289 p_buf_src_v = &(PlaneIn[2].pac_data[PlaneIn[2].u_topleft]); 290 p_buf_dest = &(PlaneOut[1].pac_data[PlaneOut[1].u_topleft]); 291 292 for(i = 0; i < PlaneOut[1].u_width*PlaneOut[1].u_height; i++) 293 { 294 *p_buf_dest++ = *p_buf_src_u++; 295 *p_buf_dest++ = *p_buf_src_v++; 296 } 297 return return_code; 298 } 299 300 M4VIFI_UInt8 M4VIFI_SemiplanarYUV420toYUV420(void *user_data, 301 M4VIFI_ImagePlane *PlaneIn, M4VIFI_ImagePlane *PlaneOut ) { 302 303 M4VIFI_UInt32 i; 304 M4VIFI_UInt8 *p_buf_src, *p_buf_dest, *p_buf_src_u, *p_buf_src_v; 305 M4VIFI_UInt8 *p_buf_dest_u,*p_buf_dest_v,*p_buf_src_uv; 306 M4VIFI_UInt8 return_code = M4VIFI_OK; 307 308 /* the filter is implemented with the assumption that the width is equal to stride */ 309 if(PlaneIn[0].u_width != PlaneIn[0].u_stride) 310 return M4VIFI_INVALID_PARAM; 311 312 /* The input Y Plane is the same as the output Y Plane */ 313 p_buf_src = &(PlaneIn[0].pac_data[PlaneIn[0].u_topleft]); 314 p_buf_dest = &(PlaneOut[0].pac_data[PlaneOut[0].u_topleft]); 315 memcpy((void *)p_buf_dest,(void *)p_buf_src , 316 PlaneOut[0].u_width * PlaneOut[0].u_height); 317 318 /* The U and V components are planar. The need to be made interleaved */ 319 p_buf_src_uv = &(PlaneIn[1].pac_data[PlaneIn[1].u_topleft]); 320 p_buf_dest_u = &(PlaneOut[1].pac_data[PlaneOut[1].u_topleft]); 321 p_buf_dest_v = &(PlaneOut[2].pac_data[PlaneOut[2].u_topleft]); 322 323 for(i = 0; i < PlaneOut[1].u_width*PlaneOut[1].u_height; i++) 324 { 325 *p_buf_dest_u++ = *p_buf_src_uv++; 326 *p_buf_dest_v++ = *p_buf_src_uv++; 327 } 328 return return_code; 329 } 330 331 332 /** 333 ****************************************************************************** 334 * prototype M4VSS3GPP_externalVideoEffectColor(M4OSA_Void *pFunctionContext, 335 * M4VIFI_ImagePlane *PlaneIn, 336 * M4VIFI_ImagePlane *PlaneOut, 337 * M4VSS3GPP_ExternalProgress *pProgress, 338 * M4OSA_UInt32 uiEffectKind) 339 * 340 * @brief This function apply a color effect on an input YUV420 planar frame 341 * @note 342 * @param pFunctionContext(IN) Contains which color to apply (not very clean ...) 343 * @param PlaneIn (IN) Input YUV420 planar 344 * @param PlaneOut (IN/OUT) Output YUV420 planar 345 * @param pProgress (IN/OUT) Progress indication (0-100) 346 * @param uiEffectKind (IN) Unused 347 * 348 * @return M4VIFI_OK: No error 349 ****************************************************************************** 350 */ 351 M4OSA_ERR M4VSS3GPP_externalVideoEffectColor(M4OSA_Void *pFunctionContext, 352 M4VIFI_ImagePlane *PlaneIn, M4VIFI_ImagePlane *PlaneOut, 353 M4VSS3GPP_ExternalProgress *pProgress, M4OSA_UInt32 uiEffectKind) { 354 355 M4VIFI_Int32 plane_number; 356 M4VIFI_UInt32 i,j; 357 M4VIFI_UInt8 *p_buf_src, *p_buf_dest; 358 M4xVSS_ColorStruct* ColorContext = (M4xVSS_ColorStruct*)pFunctionContext; 359 360 for (plane_number = 0; plane_number < 3; plane_number++) 361 { 362 p_buf_src = 363 &(PlaneIn[plane_number].pac_data[PlaneIn[plane_number].u_topleft]); 364 365 p_buf_dest = 366 &(PlaneOut[plane_number].pac_data[PlaneOut[plane_number].u_topleft]); 367 for (i = 0; i < PlaneOut[plane_number].u_height; i++) 368 { 369 /** 370 * Chrominance */ 371 if(plane_number==1 || plane_number==2) 372 { 373 //switch ((M4OSA_UInt32)pFunctionContext) // commented because a structure for the effects context exist 374 switch (ColorContext->colorEffectType) 375 { 376 case M4xVSS_kVideoEffectType_BlackAndWhite: 377 memset((void *)p_buf_dest,128, 378 PlaneIn[plane_number].u_width); 379 break; 380 case M4xVSS_kVideoEffectType_Pink: 381 memset((void *)p_buf_dest,255, 382 PlaneIn[plane_number].u_width); 383 break; 384 case M4xVSS_kVideoEffectType_Green: 385 memset((void *)p_buf_dest,0, 386 PlaneIn[plane_number].u_width); 387 break; 388 case M4xVSS_kVideoEffectType_Sepia: 389 if(plane_number==1) 390 { 391 memset((void *)p_buf_dest,117, 392 PlaneIn[plane_number].u_width); 393 } 394 else 395 { 396 memset((void *)p_buf_dest,139, 397 PlaneIn[plane_number].u_width); 398 } 399 break; 400 case M4xVSS_kVideoEffectType_Negative: 401 memcpy((void *)p_buf_dest, 402 (void *)p_buf_src ,PlaneOut[plane_number].u_width); 403 break; 404 405 case M4xVSS_kVideoEffectType_ColorRGB16: 406 { 407 M4OSA_UInt16 r = 0,g = 0,b = 0,y = 0,u = 0,v = 0; 408 409 /*first get the r, g, b*/ 410 b = (ColorContext->rgb16ColorData & 0x001f); 411 g = (ColorContext->rgb16ColorData & 0x07e0)>>5; 412 r = (ColorContext->rgb16ColorData & 0xf800)>>11; 413 414 /*keep y, but replace u and v*/ 415 if(plane_number==1) 416 { 417 /*then convert to u*/ 418 u = U16(r, g, b); 419 memset((void *)p_buf_dest,(M4OSA_UInt8)u, 420 PlaneIn[plane_number].u_width); 421 } 422 if(plane_number==2) 423 { 424 /*then convert to v*/ 425 v = V16(r, g, b); 426 memset((void *)p_buf_dest,(M4OSA_UInt8)v, 427 PlaneIn[plane_number].u_width); 428 } 429 } 430 break; 431 case M4xVSS_kVideoEffectType_Gradient: 432 { 433 M4OSA_UInt16 r = 0,g = 0,b = 0,y = 0,u = 0,v = 0; 434 435 /*first get the r, g, b*/ 436 b = (ColorContext->rgb16ColorData & 0x001f); 437 g = (ColorContext->rgb16ColorData & 0x07e0)>>5; 438 r = (ColorContext->rgb16ColorData & 0xf800)>>11; 439 440 /*for color gradation*/ 441 b = (M4OSA_UInt16)( b - ((b*i)/PlaneIn[plane_number].u_height)); 442 g = (M4OSA_UInt16)(g - ((g*i)/PlaneIn[plane_number].u_height)); 443 r = (M4OSA_UInt16)(r - ((r*i)/PlaneIn[plane_number].u_height)); 444 445 /*keep y, but replace u and v*/ 446 if(plane_number==1) 447 { 448 /*then convert to u*/ 449 u = U16(r, g, b); 450 memset((void *)p_buf_dest,(M4OSA_UInt8)u, 451 PlaneIn[plane_number].u_width); 452 } 453 if(plane_number==2) 454 { 455 /*then convert to v*/ 456 v = V16(r, g, b); 457 memset((void *)p_buf_dest,(M4OSA_UInt8)v, 458 PlaneIn[plane_number].u_width); 459 } 460 } 461 break; 462 default: 463 return M4VIFI_INVALID_PARAM; 464 } 465 } 466 /** 467 * Luminance */ 468 else 469 { 470 //switch ((M4OSA_UInt32)pFunctionContext)// commented because a structure for the effects context exist 471 switch (ColorContext->colorEffectType) 472 { 473 case M4xVSS_kVideoEffectType_Negative: 474 for(j=0;j<PlaneOut[plane_number].u_width;j++) 475 { 476 p_buf_dest[j] = 255 - p_buf_src[j]; 477 } 478 break; 479 default: 480 memcpy((void *)p_buf_dest, 481 (void *)p_buf_src ,PlaneOut[plane_number].u_width); 482 break; 483 } 484 } 485 p_buf_src += PlaneIn[plane_number].u_stride; 486 p_buf_dest += PlaneOut[plane_number].u_stride; 487 } 488 } 489 490 return M4VIFI_OK; 491 } 492 493 /** 494 ****************************************************************************** 495 * prototype M4VSS3GPP_externalVideoEffectFraming(M4OSA_Void *pFunctionContext, 496 * M4VIFI_ImagePlane *PlaneIn, 497 * M4VIFI_ImagePlane *PlaneOut, 498 * M4VSS3GPP_ExternalProgress *pProgress, 499 * M4OSA_UInt32 uiEffectKind) 500 * 501 * @brief This function add a fixed or animated image on an input YUV420 planar frame 502 * @note 503 * @param pFunctionContext(IN) Contains which color to apply (not very clean ...) 504 * @param PlaneIn (IN) Input YUV420 planar 505 * @param PlaneOut (IN/OUT) Output YUV420 planar 506 * @param pProgress (IN/OUT) Progress indication (0-100) 507 * @param uiEffectKind (IN) Unused 508 * 509 * @return M4VIFI_OK: No error 510 ****************************************************************************** 511 */ 512 M4OSA_ERR M4VSS3GPP_externalVideoEffectFraming( 513 M4OSA_Void *userData, M4VIFI_ImagePlane PlaneIn[3], 514 M4VIFI_ImagePlane *PlaneOut, M4VSS3GPP_ExternalProgress *pProgress, 515 M4OSA_UInt32 uiEffectKind ) { 516 517 M4VIFI_UInt32 x,y; 518 519 M4VIFI_UInt8 *p_in_Y = PlaneIn[0].pac_data; 520 M4VIFI_UInt8 *p_in_U = PlaneIn[1].pac_data; 521 M4VIFI_UInt8 *p_in_V = PlaneIn[2].pac_data; 522 523 M4xVSS_FramingStruct* Framing = M4OSA_NULL; 524 M4xVSS_FramingStruct* currentFraming = M4OSA_NULL; 525 M4VIFI_UInt8 *FramingRGB = M4OSA_NULL; 526 527 M4VIFI_UInt8 *p_out0; 528 M4VIFI_UInt8 *p_out1; 529 M4VIFI_UInt8 *p_out2; 530 531 M4VIFI_UInt32 topleft[2]; 532 533 M4OSA_UInt8 transparent1 = 534 (M4OSA_UInt8)((TRANSPARENT_COLOR & 0xFF00)>>8); 535 M4OSA_UInt8 transparent2 = (M4OSA_UInt8)TRANSPARENT_COLOR; 536 537 #ifndef DECODE_GIF_ON_SAVING 538 Framing = (M4xVSS_FramingStruct *)userData; 539 currentFraming = (M4xVSS_FramingStruct *)Framing->pCurrent; 540 FramingRGB = Framing->FramingRgb->pac_data; 541 #endif /*DECODE_GIF_ON_SAVING*/ 542 543 #ifdef DECODE_GIF_ON_SAVING 544 M4OSA_ERR err; 545 Framing = 546 (M4xVSS_FramingStruct *)((M4xVSS_FramingContext*)userData)->aFramingCtx; 547 if(Framing == M4OSA_NULL) 548 { 549 ((M4xVSS_FramingContext*)userData)->clipTime = pProgress->uiOutputTime; 550 err = M4xVSS_internalDecodeGIF(userData); 551 if(M4NO_ERROR != err) 552 { 553 M4OSA_TRACE1_1("M4VSS3GPP_externalVideoEffectFraming: \ 554 Error in M4xVSS_internalDecodeGIF: 0x%x", err); 555 return err; 556 } 557 Framing = 558 (M4xVSS_FramingStruct *)((M4xVSS_FramingContext*)userData)->aFramingCtx; 559 /* Initializes first GIF time */ 560 ((M4xVSS_FramingContext*)userData)->current_gif_time = 561 pProgress->uiOutputTime; 562 } 563 currentFraming = (M4xVSS_FramingStruct *)Framing; 564 FramingRGB = Framing->FramingRgb->pac_data; 565 #endif /*DECODE_GIF_ON_SAVING*/ 566 567 /** 568 * Initialize input / output plane pointers */ 569 p_in_Y += PlaneIn[0].u_topleft; 570 p_in_U += PlaneIn[1].u_topleft; 571 p_in_V += PlaneIn[2].u_topleft; 572 573 p_out0 = PlaneOut[0].pac_data; 574 p_out1 = PlaneOut[1].pac_data; 575 p_out2 = PlaneOut[2].pac_data; 576 577 /** 578 * Depending on time, initialize Framing frame to use */ 579 if(Framing->previousClipTime == -1) 580 { 581 Framing->previousClipTime = pProgress->uiOutputTime; 582 } 583 584 /** 585 * If the current clip time has reach the duration of one frame of the framing picture 586 * we need to step to next framing picture */ 587 #ifdef DECODE_GIF_ON_SAVING 588 if(((M4xVSS_FramingContext*)userData)->b_animated == M4OSA_TRUE) 589 { 590 while((((M4xVSS_FramingContext*)userData)->current_gif_time + currentFraming->duration) < pProgress->uiOutputTime) 591 { 592 ((M4xVSS_FramingContext*)userData)->clipTime = 593 pProgress->uiOutputTime; 594 595 err = M4xVSS_internalDecodeGIF(userData); 596 if(M4NO_ERROR != err) 597 { 598 M4OSA_TRACE1_1("M4VSS3GPP_externalVideoEffectFraming: Error in M4xVSS_internalDecodeGIF: 0x%x", err); 599 return err; 600 } 601 if(currentFraming->duration != 0) 602 { 603 ((M4xVSS_FramingContext*)userData)->current_gif_time += currentFraming->duration; 604 } 605 else 606 { 607 ((M4xVSS_FramingContext*)userData)->current_gif_time += 608 pProgress->uiOutputTime - Framing->previousClipTime; 609 } 610 Framing = (M4xVSS_FramingStruct *)((M4xVSS_FramingContext*)userData)->aFramingCtx; 611 currentFraming = (M4xVSS_FramingStruct *)Framing; 612 FramingRGB = Framing->FramingRgb->pac_data; 613 } 614 } 615 #else 616 Framing->pCurrent = currentFraming->pNext; 617 currentFraming = (M4xVSS_FramingStruct*)Framing->pCurrent; 618 #endif /*DECODE_GIF_ON_SAVING*/ 619 620 Framing->previousClipTime = pProgress->uiOutputTime; 621 FramingRGB = currentFraming->FramingRgb->pac_data; 622 topleft[0] = currentFraming->topleft_x; 623 topleft[1] = currentFraming->topleft_y; 624 625 for( x=0 ;x < PlaneIn[0].u_height ; x++) 626 { 627 for( y=0 ;y < PlaneIn[0].u_width ; y++) 628 { 629 /** 630 * To handle framing with input size != output size 631 * Framing is applyed if coordinates matches between framing/topleft and input plane */ 632 if( y < (topleft[0] + currentFraming->FramingYuv[0].u_width) && 633 y >= topleft[0] && 634 x < (topleft[1] + currentFraming->FramingYuv[0].u_height) && 635 x >= topleft[1]) 636 { 637 638 /*Alpha blending support*/ 639 M4OSA_Float alphaBlending = 1; 640 #ifdef DECODE_GIF_ON_SAVING 641 M4xVSS_internalEffectsAlphaBlending* alphaBlendingStruct = 642 (M4xVSS_internalEffectsAlphaBlending*)((M4xVSS_FramingContext*)userData)->alphaBlendingStruct; 643 #else 644 M4xVSS_internalEffectsAlphaBlending* alphaBlendingStruct = 645 (M4xVSS_internalEffectsAlphaBlending*)((M4xVSS_FramingStruct*)userData)->alphaBlendingStruct; 646 #endif //#ifdef DECODE_GIF_ON_SAVING 647 648 if(alphaBlendingStruct != M4OSA_NULL) 649 { 650 if(pProgress->uiProgress < (M4OSA_UInt32)(alphaBlendingStruct->m_fadeInTime*10)) 651 { 652 alphaBlending = ((M4OSA_Float)(alphaBlendingStruct->m_middle - alphaBlendingStruct->m_start)*pProgress->uiProgress/(alphaBlendingStruct->m_fadeInTime*10)); 653 alphaBlending += alphaBlendingStruct->m_start; 654 alphaBlending /= 100; 655 } 656 else if(pProgress->uiProgress >= (M4OSA_UInt32)(alphaBlendingStruct->m_fadeInTime*10) && pProgress->uiProgress < 1000 - (M4OSA_UInt32)(alphaBlendingStruct->m_fadeOutTime*10)) 657 { 658 alphaBlending = (M4OSA_Float)((M4OSA_Float)alphaBlendingStruct->m_middle/100); 659 } 660 else if(pProgress->uiProgress >= 1000 - (M4OSA_UInt32)(alphaBlendingStruct->m_fadeOutTime*10)) 661 { 662 alphaBlending = ((M4OSA_Float)(alphaBlendingStruct->m_middle - alphaBlendingStruct->m_end))*(1000 - pProgress->uiProgress)/(alphaBlendingStruct->m_fadeOutTime*10); 663 alphaBlending += alphaBlendingStruct->m_end; 664 alphaBlending /= 100; 665 } 666 } 667 668 /**/ 669 670 if((*(FramingRGB)==transparent1) && (*(FramingRGB+1)==transparent2)) 671 { 672 *( p_out0+y+x*PlaneOut[0].u_stride)=(*(p_in_Y+y+x*PlaneIn[0].u_stride)); 673 *( p_out1+(y>>1)+(x>>1)*PlaneOut[1].u_stride)=(*(p_in_U+(y>>1)+(x>>1)*PlaneIn[1].u_stride)); 674 *( p_out2+(y>>1)+(x>>1)*PlaneOut[2].u_stride)=(*(p_in_V+(y>>1)+(x>>1)*PlaneIn[2].u_stride)); 675 } 676 else 677 { 678 *( p_out0+y+x*PlaneOut[0].u_stride)=(*(currentFraming->FramingYuv[0].pac_data+(y-topleft[0])+(x-topleft[1])*currentFraming->FramingYuv[0].u_stride))*alphaBlending; 679 *( p_out0+y+x*PlaneOut[0].u_stride)+=(*(p_in_Y+y+x*PlaneIn[0].u_stride))*(1-alphaBlending); 680 *( p_out1+(y>>1)+(x>>1)*PlaneOut[1].u_stride)=(*(currentFraming->FramingYuv[1].pac_data+((y-topleft[0])>>1)+((x-topleft[1])>>1)*currentFraming->FramingYuv[1].u_stride))*alphaBlending; 681 *( p_out1+(y>>1)+(x>>1)*PlaneOut[1].u_stride)+=(*(p_in_U+(y>>1)+(x>>1)*PlaneIn[1].u_stride))*(1-alphaBlending); 682 *( p_out2+(y>>1)+(x>>1)*PlaneOut[2].u_stride)=(*(currentFraming->FramingYuv[2].pac_data+((y-topleft[0])>>1)+((x-topleft[1])>>1)*currentFraming->FramingYuv[2].u_stride))*alphaBlending; 683 *( p_out2+(y>>1)+(x>>1)*PlaneOut[2].u_stride)+=(*(p_in_V+(y>>1)+(x>>1)*PlaneIn[2].u_stride))*(1-alphaBlending); 684 } 685 if( PlaneIn[0].u_width < (topleft[0] + currentFraming->FramingYuv[0].u_width) && 686 y == PlaneIn[0].u_width-1) 687 { 688 FramingRGB = FramingRGB + 2 * (topleft[0] + currentFraming->FramingYuv[0].u_width - PlaneIn[0].u_width + 1); 689 } 690 else 691 { 692 FramingRGB = FramingRGB + 2; 693 } 694 } 695 /** 696 * Just copy input plane to output plane */ 697 else 698 { 699 *( p_out0+y+x*PlaneOut[0].u_stride)=*(p_in_Y+y+x*PlaneIn[0].u_stride); 700 *( p_out1+(y>>1)+(x>>1)*PlaneOut[1].u_stride)=*(p_in_U+(y>>1)+(x>>1)*PlaneIn[1].u_stride); 701 *( p_out2+(y>>1)+(x>>1)*PlaneOut[2].u_stride)=*(p_in_V+(y>>1)+(x>>1)*PlaneIn[2].u_stride); 702 } 703 } 704 } 705 706 #ifdef DECODE_GIF_ON_SAVING 707 if(pProgress->bIsLast == M4OSA_TRUE 708 && (M4OSA_Bool)((M4xVSS_FramingContext*)userData)->b_IsFileGif == M4OSA_TRUE) 709 { 710 M4xVSS_internalDecodeGIF_Cleaning((M4xVSS_FramingContext*)userData); 711 } 712 #endif /*DECODE_GIF_ON_SAVING*/ 713 return M4VIFI_OK; 714 } 715 716 717 /** 718 ****************************************************************************** 719 * prototype M4VSS3GPP_externalVideoEffectFifties(M4OSA_Void *pFunctionContext, 720 * M4VIFI_ImagePlane *PlaneIn, 721 * M4VIFI_ImagePlane *PlaneOut, 722 * M4VSS3GPP_ExternalProgress *pProgress, 723 * M4OSA_UInt32 uiEffectKind) 724 * 725 * @brief This function make a video look as if it was taken in the fifties 726 * @note 727 * @param pUserData (IN) Context 728 * @param pPlaneIn (IN) Input YUV420 planar 729 * @param pPlaneOut (IN/OUT) Output YUV420 planar 730 * @param pProgress (IN/OUT) Progress indication (0-100) 731 * @param uiEffectKind (IN) Unused 732 * 733 * @return M4VIFI_OK: No error 734 * @return M4ERR_PARAMETER: pFiftiesData, pPlaneOut or pProgress are NULL (DEBUG only) 735 ****************************************************************************** 736 */ 737 M4OSA_ERR M4VSS3GPP_externalVideoEffectFifties( 738 M4OSA_Void *pUserData, M4VIFI_ImagePlane *pPlaneIn, 739 M4VIFI_ImagePlane *pPlaneOut, M4VSS3GPP_ExternalProgress *pProgress, 740 M4OSA_UInt32 uiEffectKind ) 741 { 742 M4VIFI_UInt32 x, y, xShift; 743 M4VIFI_UInt8 *pInY = pPlaneIn[0].pac_data; 744 M4VIFI_UInt8 *pOutY, *pInYbegin; 745 M4VIFI_UInt8 *pInCr,* pOutCr; 746 M4VIFI_Int32 plane_number; 747 748 /* Internal context*/ 749 M4xVSS_FiftiesStruct* p_FiftiesData = (M4xVSS_FiftiesStruct *)pUserData; 750 751 /* Initialize input / output plane pointers */ 752 pInY += pPlaneIn[0].u_topleft; 753 pOutY = pPlaneOut[0].pac_data; 754 pInYbegin = pInY; 755 756 /* Initialize the random */ 757 if(p_FiftiesData->previousClipTime < 0) 758 { 759 M4OSA_randInit(); 760 M4OSA_rand((M4OSA_Int32*)&(p_FiftiesData->shiftRandomValue), (pPlaneIn[0].u_height) >> 4); 761 M4OSA_rand((M4OSA_Int32*)&(p_FiftiesData->stripeRandomValue), (pPlaneIn[0].u_width)<< 2); 762 p_FiftiesData->previousClipTime = pProgress->uiOutputTime; 763 } 764 765 /* Choose random values if we have reached the duration of a partial effect */ 766 else if( (pProgress->uiOutputTime - p_FiftiesData->previousClipTime) > p_FiftiesData->fiftiesEffectDuration) 767 { 768 M4OSA_rand((M4OSA_Int32*)&(p_FiftiesData->shiftRandomValue), (pPlaneIn[0].u_height) >> 4); 769 M4OSA_rand((M4OSA_Int32*)&(p_FiftiesData->stripeRandomValue), (pPlaneIn[0].u_width)<< 2); 770 p_FiftiesData->previousClipTime = pProgress->uiOutputTime; 771 } 772 773 /* Put in Sepia the chrominance */ 774 for (plane_number = 1; plane_number < 3; plane_number++) 775 { 776 pInCr = pPlaneIn[plane_number].pac_data + pPlaneIn[plane_number].u_topleft; 777 pOutCr = pPlaneOut[plane_number].pac_data + pPlaneOut[plane_number].u_topleft; 778 779 for (x = 0; x < pPlaneOut[plane_number].u_height; x++) 780 { 781 if (1 == plane_number) 782 memset((void *)pOutCr, 117,pPlaneIn[plane_number].u_width); /* U value */ 783 else 784 memset((void *)pOutCr, 139,pPlaneIn[plane_number].u_width); /* V value */ 785 786 pInCr += pPlaneIn[plane_number].u_stride; 787 pOutCr += pPlaneOut[plane_number].u_stride; 788 } 789 } 790 791 /* Compute the new pixels values */ 792 for( x = 0 ; x < pPlaneIn[0].u_height ; x++) 793 { 794 M4VIFI_UInt8 *p_outYtmp, *p_inYtmp; 795 796 /* Compute the xShift (random value) */ 797 if (0 == (p_FiftiesData->shiftRandomValue % 5 )) 798 xShift = (x + p_FiftiesData->shiftRandomValue ) % (pPlaneIn[0].u_height - 1); 799 else 800 xShift = (x + (pPlaneIn[0].u_height - p_FiftiesData->shiftRandomValue) ) % (pPlaneIn[0].u_height - 1); 801 802 /* Initialize the pointers */ 803 p_outYtmp = pOutY + 1; /* yShift of 1 pixel */ 804 p_inYtmp = pInYbegin + (xShift * pPlaneIn[0].u_stride); /* Apply the xShift */ 805 806 for( y = 0 ; y < pPlaneIn[0].u_width ; y++) 807 { 808 /* Set Y value */ 809 if (xShift > (pPlaneIn[0].u_height - 4)) 810 *p_outYtmp = 40; /* Add some horizontal black lines between the two parts of the image */ 811 else if ( y == p_FiftiesData->stripeRandomValue) 812 *p_outYtmp = 90; /* Add a random vertical line for the bulk */ 813 else 814 *p_outYtmp = *p_inYtmp; 815 816 817 /* Go to the next pixel */ 818 p_outYtmp++; 819 p_inYtmp++; 820 821 /* Restart at the beginning of the line for the last pixel*/ 822 if (y == (pPlaneIn[0].u_width - 2)) 823 p_outYtmp = pOutY; 824 } 825 826 /* Go to the next line */ 827 pOutY += pPlaneOut[0].u_stride; 828 } 829 830 return M4VIFI_OK; 831 } 832 833 unsigned char M4VFL_modifyLumaWithScale(M4ViComImagePlane *plane_in, 834 M4ViComImagePlane *plane_out, 835 unsigned long lum_factor, 836 void *user_data) 837 { 838 unsigned short *p_src, *p_dest, *p_src_line, *p_dest_line; 839 unsigned char *p_csrc, *p_cdest, *p_csrc_line, *p_cdest_line; 840 unsigned long pix_src; 841 unsigned long u_outpx, u_outpx2; 842 unsigned long u_width, u_stride, u_stride_out,u_height, pix; 843 long i, j; 844 845 /* copy or filter chroma */ 846 u_width = plane_in[1].u_width; 847 u_height = plane_in[1].u_height; 848 u_stride = plane_in[1].u_stride; 849 u_stride_out = plane_out[1].u_stride; 850 p_cdest_line = (unsigned char *) &plane_out[1].pac_data[plane_out[1].u_topleft]; 851 p_csrc_line = (unsigned char *) &plane_in[1].pac_data[plane_in[1].u_topleft]; 852 853 if (lum_factor > 256) 854 { 855 p_cdest = (unsigned char *) &plane_out[2].pac_data[plane_out[2].u_topleft]; 856 p_csrc = (unsigned char *) &plane_in[2].pac_data[plane_in[2].u_topleft]; 857 /* copy chroma */ 858 for (j = u_height; j != 0; j--) 859 { 860 for (i = u_width; i != 0; i--) 861 { 862 memcpy((void *)p_cdest_line, (void *)p_csrc_line, u_width); 863 memcpy((void *)p_cdest, (void *)p_csrc, u_width); 864 } 865 p_cdest_line += u_stride_out; 866 p_cdest += u_stride_out; 867 p_csrc_line += u_stride; 868 p_csrc += u_stride; 869 } 870 } 871 else 872 { 873 /* filter chroma */ 874 pix = (1024 - lum_factor) << 7; 875 for (j = u_height; j != 0; j--) 876 { 877 p_cdest = p_cdest_line; 878 p_csrc = p_csrc_line; 879 for (i = u_width; i != 0; i--) 880 { 881 *p_cdest++ = ((pix + (*p_csrc++ & 0xFF) * lum_factor) >> LUM_FACTOR_MAX); 882 } 883 p_cdest_line += u_stride_out; 884 p_csrc_line += u_stride; 885 } 886 p_cdest_line = (unsigned char *) &plane_out[2].pac_data[plane_out[2].u_topleft]; 887 p_csrc_line = (unsigned char *) &plane_in[2].pac_data[plane_in[2].u_topleft]; 888 for (j = u_height; j != 0; j--) 889 { 890 p_cdest = p_cdest_line; 891 p_csrc = p_csrc_line; 892 for (i = u_width; i != 0; i--) 893 { 894 *p_cdest++ = ((pix + (*p_csrc & 0xFF) * lum_factor) >> LUM_FACTOR_MAX); 895 } 896 p_cdest_line += u_stride_out; 897 p_csrc_line += u_stride; 898 } 899 } 900 /* apply luma factor */ 901 u_width = plane_in[0].u_width; 902 u_height = plane_in[0].u_height; 903 u_stride = (plane_in[0].u_stride >> 1); 904 u_stride_out = (plane_out[0].u_stride >> 1); 905 p_dest = (unsigned short *) &plane_out[0].pac_data[plane_out[0].u_topleft]; 906 p_src = (unsigned short *) &plane_in[0].pac_data[plane_in[0].u_topleft]; 907 p_dest_line = p_dest; 908 p_src_line = p_src; 909 910 for (j = u_height; j != 0; j--) 911 { 912 p_dest = p_dest_line; 913 p_src = p_src_line; 914 for (i = (u_width >> 1); i != 0; i--) 915 { 916 pix_src = (unsigned long) *p_src++; 917 pix = pix_src & 0xFF; 918 u_outpx = ((pix * lum_factor) >> LUM_FACTOR_MAX); 919 pix = ((pix_src & 0xFF00) >> 8); 920 u_outpx2 = (((pix * lum_factor) >> LUM_FACTOR_MAX)<< 8) ; 921 *p_dest++ = (unsigned short) (u_outpx2 | u_outpx); 922 } 923 p_dest_line += u_stride_out; 924 p_src_line += u_stride; 925 } 926 927 return 0; 928 } 929 930 /****************************************************************************** 931 * prototype M4OSA_ERR M4xVSS_internalConvertRGBtoYUV(M4xVSS_FramingStruct* framingCtx) 932 * @brief This function converts an RGB565 plane to YUV420 planar 933 * @note It is used only for framing effect 934 * It allocates output YUV planes 935 * @param framingCtx (IN) The framing struct containing input RGB565 plane 936 * 937 * @return M4NO_ERROR: No error 938 * @return M4ERR_PARAMETER: At least one of the function parameters is null 939 * @return M4ERR_ALLOC: Allocation error (no more memory) 940 ****************************************************************************** 941 */ 942 M4OSA_ERR M4xVSS_internalConvertRGBtoYUV(M4xVSS_FramingStruct* framingCtx) 943 { 944 M4OSA_ERR err; 945 946 /** 947 * Allocate output YUV planes */ 948 framingCtx->FramingYuv = (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc(3*sizeof(M4VIFI_ImagePlane), M4VS, (M4OSA_Char*)"M4xVSS_internalConvertRGBtoYUV: Output plane YUV"); 949 if(framingCtx->FramingYuv == M4OSA_NULL) 950 { 951 M4OSA_TRACE1_0("Allocation error in M4xVSS_internalConvertRGBtoYUV"); 952 return M4ERR_ALLOC; 953 } 954 framingCtx->FramingYuv[0].u_width = framingCtx->FramingRgb->u_width; 955 framingCtx->FramingYuv[0].u_height = framingCtx->FramingRgb->u_height; 956 framingCtx->FramingYuv[0].u_topleft = 0; 957 framingCtx->FramingYuv[0].u_stride = framingCtx->FramingRgb->u_width; 958 framingCtx->FramingYuv[0].pac_data = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc((framingCtx->FramingYuv[0].u_width*framingCtx->FramingYuv[0].u_height*3)>>1, M4VS, (M4OSA_Char*)"Alloc for the Convertion output YUV");; 959 if(framingCtx->FramingYuv[0].pac_data == M4OSA_NULL) 960 { 961 M4OSA_TRACE1_0("Allocation error in M4xVSS_internalConvertRGBtoYUV"); 962 return M4ERR_ALLOC; 963 } 964 framingCtx->FramingYuv[1].u_width = (framingCtx->FramingRgb->u_width)>>1; 965 framingCtx->FramingYuv[1].u_height = (framingCtx->FramingRgb->u_height)>>1; 966 framingCtx->FramingYuv[1].u_topleft = 0; 967 framingCtx->FramingYuv[1].u_stride = (framingCtx->FramingRgb->u_width)>>1; 968 framingCtx->FramingYuv[1].pac_data = framingCtx->FramingYuv[0].pac_data + framingCtx->FramingYuv[0].u_width * framingCtx->FramingYuv[0].u_height; 969 framingCtx->FramingYuv[2].u_width = (framingCtx->FramingRgb->u_width)>>1; 970 framingCtx->FramingYuv[2].u_height = (framingCtx->FramingRgb->u_height)>>1; 971 framingCtx->FramingYuv[2].u_topleft = 0; 972 framingCtx->FramingYuv[2].u_stride = (framingCtx->FramingRgb->u_width)>>1; 973 framingCtx->FramingYuv[2].pac_data = framingCtx->FramingYuv[1].pac_data + framingCtx->FramingYuv[1].u_width * framingCtx->FramingYuv[1].u_height; 974 975 /** 976 * Convert input RGB 565 to YUV 420 to be able to merge it with output video in framing effect */ 977 err = M4VIFI_xVSS_RGB565toYUV420(M4OSA_NULL, framingCtx->FramingRgb, framingCtx->FramingYuv); 978 if(err != M4NO_ERROR) 979 { 980 M4OSA_TRACE1_1("M4xVSS_internalConvertRGBtoYUV: error when converting from RGB to YUV: 0x%x\n", err); 981 } 982 983 framingCtx->duration = 0; 984 framingCtx->previousClipTime = -1; 985 framingCtx->previewOffsetClipTime = -1; 986 987 /** 988 * Only one element in the chained list (no animated image with RGB buffer...) */ 989 framingCtx->pCurrent = framingCtx; 990 framingCtx->pNext = framingCtx; 991 992 return M4NO_ERROR; 993 } 994 995 /****************************************************************************** 996 * prototype M4OSA_ERR M4xVSS_internalConvertRGB888toYUV(M4xVSS_FramingStruct* framingCtx) 997 * @brief This function converts an RGB888 plane to YUV420 planar 998 * @note It is used only for framing effect 999 * It allocates output YUV planes 1000 * @param framingCtx (IN) The framing struct containing input RGB888 plane 1001 * 1002 * @return M4NO_ERROR: No error 1003 * @return M4ERR_PARAMETER: At least one of the function parameters is null 1004 * @return M4ERR_ALLOC: Allocation error (no more memory) 1005 ****************************************************************************** 1006 */ 1007 M4OSA_ERR M4xVSS_internalConvertRGB888toYUV(M4xVSS_FramingStruct* framingCtx) 1008 { 1009 M4OSA_ERR err; 1010 1011 /** 1012 * Allocate output YUV planes */ 1013 framingCtx->FramingYuv = (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc(3*sizeof(M4VIFI_ImagePlane), M4VS, (M4OSA_Char*)"M4xVSS_internalConvertRGBtoYUV: Output plane YUV"); 1014 if(framingCtx->FramingYuv == M4OSA_NULL) 1015 { 1016 M4OSA_TRACE1_0("Allocation error in M4xVSS_internalConvertRGBtoYUV"); 1017 return M4ERR_ALLOC; 1018 } 1019 framingCtx->FramingYuv[0].u_width = framingCtx->FramingRgb->u_width; 1020 framingCtx->FramingYuv[0].u_height = framingCtx->FramingRgb->u_height; 1021 framingCtx->FramingYuv[0].u_topleft = 0; 1022 framingCtx->FramingYuv[0].u_stride = framingCtx->FramingRgb->u_width; 1023 framingCtx->FramingYuv[0].pac_data = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc((framingCtx->FramingYuv[0].u_width*framingCtx->FramingYuv[0].u_height*3)>>1, M4VS, (M4OSA_Char*)"Alloc for the Convertion output YUV");; 1024 if(framingCtx->FramingYuv[0].pac_data == M4OSA_NULL) 1025 { 1026 M4OSA_TRACE1_0("Allocation error in M4xVSS_internalConvertRGBtoYUV"); 1027 return M4ERR_ALLOC; 1028 } 1029 framingCtx->FramingYuv[1].u_width = (framingCtx->FramingRgb->u_width)>>1; 1030 framingCtx->FramingYuv[1].u_height = (framingCtx->FramingRgb->u_height)>>1; 1031 framingCtx->FramingYuv[1].u_topleft = 0; 1032 framingCtx->FramingYuv[1].u_stride = (framingCtx->FramingRgb->u_width)>>1; 1033 framingCtx->FramingYuv[1].pac_data = framingCtx->FramingYuv[0].pac_data + framingCtx->FramingYuv[0].u_width * framingCtx->FramingYuv[0].u_height; 1034 framingCtx->FramingYuv[2].u_width = (framingCtx->FramingRgb->u_width)>>1; 1035 framingCtx->FramingYuv[2].u_height = (framingCtx->FramingRgb->u_height)>>1; 1036 framingCtx->FramingYuv[2].u_topleft = 0; 1037 framingCtx->FramingYuv[2].u_stride = (framingCtx->FramingRgb->u_width)>>1; 1038 framingCtx->FramingYuv[2].pac_data = framingCtx->FramingYuv[1].pac_data + framingCtx->FramingYuv[1].u_width * framingCtx->FramingYuv[1].u_height; 1039 1040 /** 1041 * Convert input RGB888 to YUV 420 to be able to merge it with output video in framing effect */ 1042 err = M4VIFI_RGB888toYUV420(M4OSA_NULL, framingCtx->FramingRgb, framingCtx->FramingYuv); 1043 if(err != M4NO_ERROR) 1044 { 1045 M4OSA_TRACE1_1("M4xVSS_internalConvertRGBtoYUV: error when converting from RGB to YUV: 0x%x\n", err); 1046 } 1047 1048 framingCtx->duration = 0; 1049 framingCtx->previousClipTime = -1; 1050 framingCtx->previewOffsetClipTime = -1; 1051 1052 /** 1053 * Only one element in the chained list (no animated image with RGB buffer...) */ 1054 framingCtx->pCurrent = framingCtx; 1055 framingCtx->pNext = framingCtx; 1056 1057 return M4NO_ERROR; 1058 } 1059 1060 /** 1061 ****************************************************************************** 1062 * M4VIFI_UInt8 M4VIFI_RGB565toYUV420 (void *pUserData, 1063 * M4VIFI_ImagePlane *pPlaneIn, 1064 * M4VIFI_ImagePlane *pPlaneOut) 1065 * @author Patrice Martinez / Philips Digital Networks - MP4Net 1066 * @brief transform RGB565 image to a YUV420 image. 1067 * @note Convert RGB565 to YUV420, 1068 * Loop on each row ( 2 rows by 2 rows ) 1069 * Loop on each column ( 2 col by 2 col ) 1070 * Get 4 RGB samples from input data and build 4 output Y samples 1071 * and each single U & V data 1072 * end loop on col 1073 * end loop on row 1074 * @param pUserData: (IN) User Specific Data 1075 * @param pPlaneIn: (IN) Pointer to RGB565 Plane 1076 * @param pPlaneOut: (OUT) Pointer to YUV420 buffer Plane 1077 * @return M4VIFI_OK: there is no error 1078 * @return M4VIFI_ILLEGAL_FRAME_HEIGHT: YUV Plane height is ODD 1079 * @return M4VIFI_ILLEGAL_FRAME_WIDTH: YUV Plane width is ODD 1080 ****************************************************************************** 1081 */ 1082 M4VIFI_UInt8 M4VIFI_xVSS_RGB565toYUV420(void *pUserData, M4VIFI_ImagePlane *pPlaneIn, 1083 M4VIFI_ImagePlane *pPlaneOut) 1084 { 1085 M4VIFI_UInt32 u32_width, u32_height; 1086 M4VIFI_UInt32 u32_stride_Y, u32_stride2_Y, u32_stride_U, u32_stride_V; 1087 M4VIFI_UInt32 u32_stride_rgb, u32_stride_2rgb; 1088 M4VIFI_UInt32 u32_col, u32_row; 1089 1090 M4VIFI_Int32 i32_r00, i32_r01, i32_r10, i32_r11; 1091 M4VIFI_Int32 i32_g00, i32_g01, i32_g10, i32_g11; 1092 M4VIFI_Int32 i32_b00, i32_b01, i32_b10, i32_b11; 1093 M4VIFI_Int32 i32_y00, i32_y01, i32_y10, i32_y11; 1094 M4VIFI_Int32 i32_u00, i32_u01, i32_u10, i32_u11; 1095 M4VIFI_Int32 i32_v00, i32_v01, i32_v10, i32_v11; 1096 M4VIFI_UInt8 *pu8_yn, *pu8_ys, *pu8_u, *pu8_v; 1097 M4VIFI_UInt8 *pu8_y_data, *pu8_u_data, *pu8_v_data; 1098 M4VIFI_UInt8 *pu8_rgbn_data, *pu8_rgbn; 1099 M4VIFI_UInt16 u16_pix1, u16_pix2, u16_pix3, u16_pix4; 1100 M4VIFI_UInt8 count_null=0; 1101 1102 /* Check planes height are appropriate */ 1103 if( (pPlaneIn->u_height != pPlaneOut[0].u_height) || 1104 (pPlaneOut[0].u_height != (pPlaneOut[1].u_height<<1)) || 1105 (pPlaneOut[0].u_height != (pPlaneOut[2].u_height<<1))) 1106 { 1107 return M4VIFI_ILLEGAL_FRAME_HEIGHT; 1108 } 1109 1110 /* Check planes width are appropriate */ 1111 if( (pPlaneIn->u_width != pPlaneOut[0].u_width) || 1112 (pPlaneOut[0].u_width != (pPlaneOut[1].u_width<<1)) || 1113 (pPlaneOut[0].u_width != (pPlaneOut[2].u_width<<1))) 1114 { 1115 return M4VIFI_ILLEGAL_FRAME_WIDTH; 1116 } 1117 1118 /* Set the pointer to the beginning of the output data buffers */ 1119 pu8_y_data = pPlaneOut[0].pac_data + pPlaneOut[0].u_topleft; 1120 pu8_u_data = pPlaneOut[1].pac_data + pPlaneOut[1].u_topleft; 1121 pu8_v_data = pPlaneOut[2].pac_data + pPlaneOut[2].u_topleft; 1122 1123 /* Set the pointer to the beginning of the input data buffers */ 1124 pu8_rgbn_data = pPlaneIn->pac_data + pPlaneIn->u_topleft; 1125 1126 /* Get the size of the output image */ 1127 u32_width = pPlaneOut[0].u_width; 1128 u32_height = pPlaneOut[0].u_height; 1129 1130 /* Set the size of the memory jumps corresponding to row jump in each output plane */ 1131 u32_stride_Y = pPlaneOut[0].u_stride; 1132 u32_stride2_Y = u32_stride_Y << 1; 1133 u32_stride_U = pPlaneOut[1].u_stride; 1134 u32_stride_V = pPlaneOut[2].u_stride; 1135 1136 /* Set the size of the memory jumps corresponding to row jump in input plane */ 1137 u32_stride_rgb = pPlaneIn->u_stride; 1138 u32_stride_2rgb = u32_stride_rgb << 1; 1139 1140 1141 /* Loop on each row of the output image, input coordinates are estimated from output ones */ 1142 /* Two YUV rows are computed at each pass */ 1143 for (u32_row = u32_height ;u32_row != 0; u32_row -=2) 1144 { 1145 /* Current Y plane row pointers */ 1146 pu8_yn = pu8_y_data; 1147 /* Next Y plane row pointers */ 1148 pu8_ys = pu8_yn + u32_stride_Y; 1149 /* Current U plane row pointer */ 1150 pu8_u = pu8_u_data; 1151 /* Current V plane row pointer */ 1152 pu8_v = pu8_v_data; 1153 1154 pu8_rgbn = pu8_rgbn_data; 1155 1156 /* Loop on each column of the output image */ 1157 for (u32_col = u32_width; u32_col != 0 ; u32_col -=2) 1158 { 1159 /* Get four RGB 565 samples from input data */ 1160 u16_pix1 = *( (M4VIFI_UInt16 *) pu8_rgbn); 1161 u16_pix2 = *( (M4VIFI_UInt16 *) (pu8_rgbn + CST_RGB_16_SIZE)); 1162 u16_pix3 = *( (M4VIFI_UInt16 *) (pu8_rgbn + u32_stride_rgb)); 1163 u16_pix4 = *( (M4VIFI_UInt16 *) (pu8_rgbn + u32_stride_rgb + CST_RGB_16_SIZE)); 1164 1165 /* Unpack RGB565 to 8bit R, G, B */ 1166 /* (x,y) */ 1167 GET_RGB565(i32_b00,i32_g00,i32_r00,u16_pix1); 1168 /* (x+1,y) */ 1169 GET_RGB565(i32_b10,i32_g10,i32_r10,u16_pix2); 1170 /* (x,y+1) */ 1171 GET_RGB565(i32_b01,i32_g01,i32_r01,u16_pix3); 1172 /* (x+1,y+1) */ 1173 GET_RGB565(i32_b11,i32_g11,i32_r11,u16_pix4); 1174 /* If RGB is transparent color (0, 63, 0), we transform it to white (31,63,31) */ 1175 if(i32_b00 == 0 && i32_g00 == 63 && i32_r00 == 0) 1176 { 1177 i32_b00 = 31; 1178 i32_r00 = 31; 1179 } 1180 if(i32_b10 == 0 && i32_g10 == 63 && i32_r10 == 0) 1181 { 1182 i32_b10 = 31; 1183 i32_r10 = 31; 1184 } 1185 if(i32_b01 == 0 && i32_g01 == 63 && i32_r01 == 0) 1186 { 1187 i32_b01 = 31; 1188 i32_r01 = 31; 1189 } 1190 if(i32_b11 == 0 && i32_g11 == 63 && i32_r11 == 0) 1191 { 1192 i32_b11 = 31; 1193 i32_r11 = 31; 1194 } 1195 /* Convert RGB value to YUV */ 1196 i32_u00 = U16(i32_r00, i32_g00, i32_b00); 1197 i32_v00 = V16(i32_r00, i32_g00, i32_b00); 1198 /* luminance value */ 1199 i32_y00 = Y16(i32_r00, i32_g00, i32_b00); 1200 1201 i32_u10 = U16(i32_r10, i32_g10, i32_b10); 1202 i32_v10 = V16(i32_r10, i32_g10, i32_b10); 1203 /* luminance value */ 1204 i32_y10 = Y16(i32_r10, i32_g10, i32_b10); 1205 1206 i32_u01 = U16(i32_r01, i32_g01, i32_b01); 1207 i32_v01 = V16(i32_r01, i32_g01, i32_b01); 1208 /* luminance value */ 1209 i32_y01 = Y16(i32_r01, i32_g01, i32_b01); 1210 1211 i32_u11 = U16(i32_r11, i32_g11, i32_b11); 1212 i32_v11 = V16(i32_r11, i32_g11, i32_b11); 1213 /* luminance value */ 1214 i32_y11 = Y16(i32_r11, i32_g11, i32_b11); 1215 1216 /* Store luminance data */ 1217 pu8_yn[0] = (M4VIFI_UInt8)i32_y00; 1218 pu8_yn[1] = (M4VIFI_UInt8)i32_y10; 1219 pu8_ys[0] = (M4VIFI_UInt8)i32_y01; 1220 pu8_ys[1] = (M4VIFI_UInt8)i32_y11; 1221 *pu8_u = (M4VIFI_UInt8)((i32_u00 + i32_u01 + i32_u10 + i32_u11 + 2) >> 2); 1222 *pu8_v = (M4VIFI_UInt8)((i32_v00 + i32_v01 + i32_v10 + i32_v11 + 2) >> 2); 1223 /* Prepare for next column */ 1224 pu8_rgbn += (CST_RGB_16_SIZE<<1); 1225 /* Update current Y plane line pointer*/ 1226 pu8_yn += 2; 1227 /* Update next Y plane line pointer*/ 1228 pu8_ys += 2; 1229 /* Update U plane line pointer*/ 1230 pu8_u ++; 1231 /* Update V plane line pointer*/ 1232 pu8_v ++; 1233 } /* End of horizontal scanning */ 1234 1235 /* Prepare pointers for the next row */ 1236 pu8_y_data += u32_stride2_Y; 1237 pu8_u_data += u32_stride_U; 1238 pu8_v_data += u32_stride_V; 1239 pu8_rgbn_data += u32_stride_2rgb; 1240 1241 1242 } /* End of vertical scanning */ 1243 1244 return M4VIFI_OK; 1245 } 1246 1247 /*************************************************************************** 1248 Proto: 1249 M4VIFI_UInt8 M4VIFI_RGB888toYUV420(void *pUserData, M4VIFI_ImagePlane *PlaneIn, M4VIFI_ImagePlane PlaneOut[3]); 1250 Author: Patrice Martinez / Philips Digital Networks - MP4Net 1251 Purpose: filling of the YUV420 plane from a BGR24 plane 1252 Abstract: Loop on each row ( 2 rows by 2 rows ) 1253 Loop on each column ( 2 col by 2 col ) 1254 Get 4 BGR samples from input data and build 4 output Y samples and each single U & V data 1255 end loop on col 1256 end loop on row 1257 1258 In: RGB24 plane 1259 InOut: none 1260 Out: array of 3 M4VIFI_ImagePlane structures 1261 Modified: ML: RGB function modified to BGR. 1262 ***************************************************************************/ 1263 M4VIFI_UInt8 M4VIFI_RGB888toYUV420(void *pUserData, M4VIFI_ImagePlane *PlaneIn, M4VIFI_ImagePlane PlaneOut[3]) 1264 { 1265 1266 M4VIFI_UInt32 u32_width, u32_height; 1267 M4VIFI_UInt32 u32_stride_Y, u32_stride2_Y, u32_stride_U, u32_stride_V, u32_stride_rgb, u32_stride_2rgb; 1268 M4VIFI_UInt32 u32_col, u32_row; 1269 1270 M4VIFI_Int32 i32_r00, i32_r01, i32_r10, i32_r11; 1271 M4VIFI_Int32 i32_g00, i32_g01, i32_g10, i32_g11; 1272 M4VIFI_Int32 i32_b00, i32_b01, i32_b10, i32_b11; 1273 M4VIFI_Int32 i32_y00, i32_y01, i32_y10, i32_y11; 1274 M4VIFI_Int32 i32_u00, i32_u01, i32_u10, i32_u11; 1275 M4VIFI_Int32 i32_v00, i32_v01, i32_v10, i32_v11; 1276 M4VIFI_UInt8 *pu8_yn, *pu8_ys, *pu8_u, *pu8_v; 1277 M4VIFI_UInt8 *pu8_y_data, *pu8_u_data, *pu8_v_data; 1278 M4VIFI_UInt8 *pu8_rgbn_data, *pu8_rgbn; 1279 1280 /* check sizes */ 1281 if( (PlaneIn->u_height != PlaneOut[0].u_height) || 1282 (PlaneOut[0].u_height != (PlaneOut[1].u_height<<1)) || 1283 (PlaneOut[0].u_height != (PlaneOut[2].u_height<<1))) 1284 return M4VIFI_ILLEGAL_FRAME_HEIGHT; 1285 1286 if( (PlaneIn->u_width != PlaneOut[0].u_width) || 1287 (PlaneOut[0].u_width != (PlaneOut[1].u_width<<1)) || 1288 (PlaneOut[0].u_width != (PlaneOut[2].u_width<<1))) 1289 return M4VIFI_ILLEGAL_FRAME_WIDTH; 1290 1291 1292 /* set the pointer to the beginning of the output data buffers */ 1293 pu8_y_data = PlaneOut[0].pac_data + PlaneOut[0].u_topleft; 1294 pu8_u_data = PlaneOut[1].pac_data + PlaneOut[1].u_topleft; 1295 pu8_v_data = PlaneOut[2].pac_data + PlaneOut[2].u_topleft; 1296 1297 /* idem for input buffer */ 1298 pu8_rgbn_data = PlaneIn->pac_data + PlaneIn->u_topleft; 1299 1300 /* get the size of the output image */ 1301 u32_width = PlaneOut[0].u_width; 1302 u32_height = PlaneOut[0].u_height; 1303 1304 /* set the size of the memory jumps corresponding to row jump in each output plane */ 1305 u32_stride_Y = PlaneOut[0].u_stride; 1306 u32_stride2_Y= u32_stride_Y << 1; 1307 u32_stride_U = PlaneOut[1].u_stride; 1308 u32_stride_V = PlaneOut[2].u_stride; 1309 1310 /* idem for input plane */ 1311 u32_stride_rgb = PlaneIn->u_stride; 1312 u32_stride_2rgb = u32_stride_rgb << 1; 1313 1314 /* loop on each row of the output image, input coordinates are estimated from output ones */ 1315 /* two YUV rows are computed at each pass */ 1316 for (u32_row = u32_height ;u32_row != 0; u32_row -=2) 1317 { 1318 /* update working pointers */ 1319 pu8_yn = pu8_y_data; 1320 pu8_ys = pu8_yn + u32_stride_Y; 1321 1322 pu8_u = pu8_u_data; 1323 pu8_v = pu8_v_data; 1324 1325 pu8_rgbn= pu8_rgbn_data; 1326 1327 /* loop on each column of the output image*/ 1328 for (u32_col = u32_width; u32_col != 0 ; u32_col -=2) 1329 { 1330 /* get RGB samples of 4 pixels */ 1331 GET_RGB24(i32_r00, i32_g00, i32_b00, pu8_rgbn, 0); 1332 GET_RGB24(i32_r10, i32_g10, i32_b10, pu8_rgbn, CST_RGB_24_SIZE); 1333 GET_RGB24(i32_r01, i32_g01, i32_b01, pu8_rgbn, u32_stride_rgb); 1334 GET_RGB24(i32_r11, i32_g11, i32_b11, pu8_rgbn, u32_stride_rgb + CST_RGB_24_SIZE); 1335 1336 i32_u00 = U24(i32_r00, i32_g00, i32_b00); 1337 i32_v00 = V24(i32_r00, i32_g00, i32_b00); 1338 i32_y00 = Y24(i32_r00, i32_g00, i32_b00); /* matrix luminance */ 1339 pu8_yn[0]= (M4VIFI_UInt8)i32_y00; 1340 1341 i32_u10 = U24(i32_r10, i32_g10, i32_b10); 1342 i32_v10 = V24(i32_r10, i32_g10, i32_b10); 1343 i32_y10 = Y24(i32_r10, i32_g10, i32_b10); 1344 pu8_yn[1]= (M4VIFI_UInt8)i32_y10; 1345 1346 i32_u01 = U24(i32_r01, i32_g01, i32_b01); 1347 i32_v01 = V24(i32_r01, i32_g01, i32_b01); 1348 i32_y01 = Y24(i32_r01, i32_g01, i32_b01); 1349 pu8_ys[0]= (M4VIFI_UInt8)i32_y01; 1350 1351 i32_u11 = U24(i32_r11, i32_g11, i32_b11); 1352 i32_v11 = V24(i32_r11, i32_g11, i32_b11); 1353 i32_y11 = Y24(i32_r11, i32_g11, i32_b11); 1354 pu8_ys[1] = (M4VIFI_UInt8)i32_y11; 1355 1356 *pu8_u = (M4VIFI_UInt8)((i32_u00 + i32_u01 + i32_u10 + i32_u11 + 2) >> 2); 1357 *pu8_v = (M4VIFI_UInt8)((i32_v00 + i32_v01 + i32_v10 + i32_v11 + 2) >> 2); 1358 1359 pu8_rgbn += (CST_RGB_24_SIZE<<1); 1360 pu8_yn += 2; 1361 pu8_ys += 2; 1362 1363 pu8_u ++; 1364 pu8_v ++; 1365 } /* end of horizontal scanning */ 1366 1367 pu8_y_data += u32_stride2_Y; 1368 pu8_u_data += u32_stride_U; 1369 pu8_v_data += u32_stride_V; 1370 pu8_rgbn_data += u32_stride_2rgb; 1371 1372 1373 } /* End of vertical scanning */ 1374 1375 return M4VIFI_OK; 1376 } 1377 1378 /** YUV420 to YUV420 */ 1379 /** 1380 ******************************************************************************************* 1381 * M4VIFI_UInt8 M4VIFI_YUV420toYUV420 (void *pUserData, 1382 * M4VIFI_ImagePlane *pPlaneIn, 1383 * M4VIFI_ImagePlane *pPlaneOut) 1384 * @brief Transform YUV420 image to a YUV420 image. 1385 * @param pUserData: (IN) User Specific Data (Unused - could be NULL) 1386 * @param pPlaneIn: (IN) Pointer to YUV plane buffer 1387 * @param pPlaneOut: (OUT) Pointer to YUV Plane 1388 * @return M4VIFI_OK: there is no error 1389 * @return M4VIFI_ILLEGAL_FRAME_HEIGHT: Error in plane height 1390 * @return M4VIFI_ILLEGAL_FRAME_WIDTH: Error in plane width 1391 ******************************************************************************************* 1392 */ 1393 1394 M4VIFI_UInt8 M4VIFI_YUV420toYUV420(void *user_data, M4VIFI_ImagePlane PlaneIn[3], M4VIFI_ImagePlane *PlaneOut ) 1395 { 1396 M4VIFI_Int32 plane_number; 1397 M4VIFI_UInt32 i; 1398 M4VIFI_UInt8 *p_buf_src, *p_buf_dest; 1399 1400 for (plane_number = 0; plane_number < 3; plane_number++) 1401 { 1402 p_buf_src = &(PlaneIn[plane_number].pac_data[PlaneIn[plane_number].u_topleft]); 1403 p_buf_dest = &(PlaneOut[plane_number].pac_data[PlaneOut[plane_number].u_topleft]); 1404 for (i = 0; i < PlaneOut[plane_number].u_height; i++) 1405 { 1406 memcpy((void *)p_buf_dest, (void *)p_buf_src ,PlaneOut[plane_number].u_width); 1407 p_buf_src += PlaneIn[plane_number].u_stride; 1408 p_buf_dest += PlaneOut[plane_number].u_stride; 1409 } 1410 } 1411 return M4VIFI_OK; 1412 } 1413 1414 /** 1415 *********************************************************************************************** 1416 * M4VIFI_UInt8 M4VIFI_ResizeBilinearYUV420toYUV420(void *pUserData, M4VIFI_ImagePlane *pPlaneIn, 1417 * M4VIFI_ImagePlane *pPlaneOut) 1418 * @author David Dana (PHILIPS Software) 1419 * @brief Resizes YUV420 Planar plane. 1420 * @note Basic structure of the function 1421 * Loop on each row (step 2) 1422 * Loop on each column (step 2) 1423 * Get four Y samples and 1 U & V sample 1424 * Resize the Y with corresponing U and V samples 1425 * Place the YUV in the ouput plane 1426 * end loop column 1427 * end loop row 1428 * For resizing bilinear interpolation linearly interpolates along 1429 * each row, and then uses that result in a linear interpolation down each column. 1430 * Each estimated pixel in the output image is a weighted 1431 * combination of its four neighbours. The ratio of compression 1432 * or dilatation is estimated using input and output sizes. 1433 * @param pUserData: (IN) User Data 1434 * @param pPlaneIn: (IN) Pointer to YUV420 (Planar) plane buffer 1435 * @param pPlaneOut: (OUT) Pointer to YUV420 (Planar) plane 1436 * @return M4VIFI_OK: there is no error 1437 * @return M4VIFI_ILLEGAL_FRAME_HEIGHT: Error in height 1438 * @return M4VIFI_ILLEGAL_FRAME_WIDTH: Error in width 1439 *********************************************************************************************** 1440 */ 1441 M4VIFI_UInt8 M4VIFI_ResizeBilinearYUV420toYUV420(void *pUserData, 1442 M4VIFI_ImagePlane *pPlaneIn, 1443 M4VIFI_ImagePlane *pPlaneOut) 1444 { 1445 M4VIFI_UInt8 *pu8_data_in, *pu8_data_out, *pu8dum; 1446 M4VIFI_UInt32 u32_plane; 1447 M4VIFI_UInt32 u32_width_in, u32_width_out, u32_height_in, u32_height_out; 1448 M4VIFI_UInt32 u32_stride_in, u32_stride_out; 1449 M4VIFI_UInt32 u32_x_inc, u32_y_inc; 1450 M4VIFI_UInt32 u32_x_accum, u32_y_accum, u32_x_accum_start; 1451 M4VIFI_UInt32 u32_width, u32_height; 1452 M4VIFI_UInt32 u32_y_frac; 1453 M4VIFI_UInt32 u32_x_frac; 1454 M4VIFI_UInt32 u32_temp_value; 1455 M4VIFI_UInt8 *pu8_src_top; 1456 M4VIFI_UInt8 *pu8_src_bottom; 1457 1458 M4VIFI_UInt8 u8Wflag = 0; 1459 M4VIFI_UInt8 u8Hflag = 0; 1460 M4VIFI_UInt32 loop = 0; 1461 1462 1463 /* 1464 If input width is equal to output width and input height equal to 1465 output height then M4VIFI_YUV420toYUV420 is called. 1466 */ 1467 if ((pPlaneIn[0].u_height == pPlaneOut[0].u_height) && 1468 (pPlaneIn[0].u_width == pPlaneOut[0].u_width)) 1469 { 1470 return M4VIFI_YUV420toYUV420(pUserData, pPlaneIn, pPlaneOut); 1471 } 1472 1473 /* Check for the YUV width and height are even */ 1474 if ((IS_EVEN(pPlaneIn[0].u_height) == FALSE) || 1475 (IS_EVEN(pPlaneOut[0].u_height) == FALSE)) 1476 { 1477 return M4VIFI_ILLEGAL_FRAME_HEIGHT; 1478 } 1479 1480 if ((IS_EVEN(pPlaneIn[0].u_width) == FALSE) || 1481 (IS_EVEN(pPlaneOut[0].u_width) == FALSE)) 1482 { 1483 return M4VIFI_ILLEGAL_FRAME_WIDTH; 1484 } 1485 1486 /* Loop on planes */ 1487 for(u32_plane = 0;u32_plane < PLANES;u32_plane++) 1488 { 1489 /* Set the working pointers at the beginning of the input/output data field */ 1490 pu8_data_in = pPlaneIn[u32_plane].pac_data + pPlaneIn[u32_plane].u_topleft; 1491 pu8_data_out = pPlaneOut[u32_plane].pac_data + pPlaneOut[u32_plane].u_topleft; 1492 1493 /* Get the memory jump corresponding to a row jump */ 1494 u32_stride_in = pPlaneIn[u32_plane].u_stride; 1495 u32_stride_out = pPlaneOut[u32_plane].u_stride; 1496 1497 /* Set the bounds of the active image */ 1498 u32_width_in = pPlaneIn[u32_plane].u_width; 1499 u32_height_in = pPlaneIn[u32_plane].u_height; 1500 1501 u32_width_out = pPlaneOut[u32_plane].u_width; 1502 u32_height_out = pPlaneOut[u32_plane].u_height; 1503 1504 /* 1505 For the case , width_out = width_in , set the flag to avoid 1506 accessing one column beyond the input width.In this case the last 1507 column is replicated for processing 1508 */ 1509 if (u32_width_out == u32_width_in) { 1510 u32_width_out = u32_width_out-1; 1511 u8Wflag = 1; 1512 } 1513 1514 /* Compute horizontal ratio between src and destination width.*/ 1515 if (u32_width_out >= u32_width_in) 1516 { 1517 u32_x_inc = ((u32_width_in-1) * MAX_SHORT) / (u32_width_out-1); 1518 } 1519 else 1520 { 1521 u32_x_inc = (u32_width_in * MAX_SHORT) / (u32_width_out); 1522 } 1523 1524 /* 1525 For the case , height_out = height_in , set the flag to avoid 1526 accessing one row beyond the input height.In this case the last 1527 row is replicated for processing 1528 */ 1529 if (u32_height_out == u32_height_in) { 1530 u32_height_out = u32_height_out-1; 1531 u8Hflag = 1; 1532 } 1533 1534 /* Compute vertical ratio between src and destination height.*/ 1535 if (u32_height_out >= u32_height_in) 1536 { 1537 u32_y_inc = ((u32_height_in - 1) * MAX_SHORT) / (u32_height_out-1); 1538 } 1539 else 1540 { 1541 u32_y_inc = (u32_height_in * MAX_SHORT) / (u32_height_out); 1542 } 1543 1544 /* 1545 Calculate initial accumulator value : u32_y_accum_start. 1546 u32_y_accum_start is coded on 15 bits, and represents a value 1547 between 0 and 0.5 1548 */ 1549 if (u32_y_inc >= MAX_SHORT) 1550 { 1551 /* 1552 Keep the fractionnal part, assimung that integer part is coded 1553 on the 16 high bits and the fractional on the 15 low bits 1554 */ 1555 u32_y_accum = u32_y_inc & 0xffff; 1556 1557 if (!u32_y_accum) 1558 { 1559 u32_y_accum = MAX_SHORT; 1560 } 1561 1562 u32_y_accum >>= 1; 1563 } 1564 else 1565 { 1566 u32_y_accum = 0; 1567 } 1568 1569 1570 /* 1571 Calculate initial accumulator value : u32_x_accum_start. 1572 u32_x_accum_start is coded on 15 bits, and represents a value 1573 between 0 and 0.5 1574 */ 1575 if (u32_x_inc >= MAX_SHORT) 1576 { 1577 u32_x_accum_start = u32_x_inc & 0xffff; 1578 1579 if (!u32_x_accum_start) 1580 { 1581 u32_x_accum_start = MAX_SHORT; 1582 } 1583 1584 u32_x_accum_start >>= 1; 1585 } 1586 else 1587 { 1588 u32_x_accum_start = 0; 1589 } 1590 1591 u32_height = u32_height_out; 1592 1593 /* 1594 Bilinear interpolation linearly interpolates along each row, and 1595 then uses that result in a linear interpolation donw each column. 1596 Each estimated pixel in the output image is a weighted combination 1597 of its four neighbours according to the formula: 1598 F(p',q')=f(p,q)R(-a)R(b)+f(p,q-1)R(-a)R(b-1)+f(p+1,q)R(1-a)R(b)+ 1599 f(p+&,q+1)R(1-a)R(b-1) with R(x) = / x+1 -1 =< x =< 0 \ 1-x 1600 0 =< x =< 1 and a (resp. b)weighting coefficient is the distance 1601 from the nearest neighbor in the p (resp. q) direction 1602 */ 1603 1604 do { /* Scan all the row */ 1605 1606 /* Vertical weight factor */ 1607 u32_y_frac = (u32_y_accum>>12)&15; 1608 1609 /* Reinit accumulator */ 1610 u32_x_accum = u32_x_accum_start; 1611 1612 u32_width = u32_width_out; 1613 1614 do { /* Scan along each row */ 1615 pu8_src_top = pu8_data_in + (u32_x_accum >> 16); 1616 pu8_src_bottom = pu8_src_top + u32_stride_in; 1617 u32_x_frac = (u32_x_accum >> 12)&15; /* Horizontal weight factor */ 1618 1619 /* Weighted combination */ 1620 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[0]*(16-u32_x_frac) + 1621 pu8_src_top[1]*u32_x_frac)*(16-u32_y_frac) + 1622 (pu8_src_bottom[0]*(16-u32_x_frac) + 1623 pu8_src_bottom[1]*u32_x_frac)*u32_y_frac )>>8); 1624 1625 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 1626 1627 /* Update horizontal accumulator */ 1628 u32_x_accum += u32_x_inc; 1629 } while(--u32_width); 1630 1631 /* 1632 This u8Wflag flag gets in to effect if input and output 1633 width is same, and height may be different. So previous 1634 pixel is replicated here 1635 */ 1636 if (u8Wflag) { 1637 *pu8_data_out = (M4VIFI_UInt8)u32_temp_value; 1638 } 1639 1640 pu8dum = (pu8_data_out-u32_width_out); 1641 pu8_data_out = pu8_data_out + u32_stride_out - u32_width_out; 1642 1643 /* Update vertical accumulator */ 1644 u32_y_accum += u32_y_inc; 1645 if (u32_y_accum>>16) { 1646 pu8_data_in = pu8_data_in + (u32_y_accum >> 16) * u32_stride_in; 1647 u32_y_accum &= 0xffff; 1648 } 1649 } while(--u32_height); 1650 1651 /* 1652 This u8Hflag flag gets in to effect if input and output height 1653 is same, and width may be different. So previous pixel row is 1654 replicated here 1655 */ 1656 if (u8Hflag) { 1657 for(loop =0; loop < (u32_width_out+u8Wflag); loop++) { 1658 *pu8_data_out++ = (M4VIFI_UInt8)*pu8dum++; 1659 } 1660 } 1661 } 1662 1663 return M4VIFI_OK; 1664 } 1665 1666 M4OSA_ERR applyRenderingMode(M4VIFI_ImagePlane* pPlaneIn, M4VIFI_ImagePlane* pPlaneOut, M4xVSS_MediaRendering mediaRendering) 1667 { 1668 M4OSA_ERR err = M4NO_ERROR; 1669 1670 if(mediaRendering == M4xVSS_kResizing) 1671 { 1672 /** 1673 * Call the resize filter. From the intermediate frame to the encoder image plane */ 1674 err = M4VIFI_ResizeBilinearYUV420toYUV420(M4OSA_NULL, pPlaneIn, pPlaneOut); 1675 if (M4NO_ERROR != err) 1676 { 1677 M4OSA_TRACE1_1("applyRenderingMode: M4ViFilResizeBilinearYUV420toYUV420 returns 0x%x!", err); 1678 return err; 1679 } 1680 } 1681 else 1682 { 1683 M4AIR_Params Params; 1684 M4OSA_Context m_air_context; 1685 M4VIFI_ImagePlane pImagePlanesTemp[3]; 1686 M4VIFI_ImagePlane* pPlaneTemp; 1687 M4OSA_UInt8* pOutPlaneY = pPlaneOut[0].pac_data + pPlaneOut[0].u_topleft; 1688 M4OSA_UInt8* pOutPlaneU = pPlaneOut[1].pac_data + pPlaneOut[1].u_topleft; 1689 M4OSA_UInt8* pOutPlaneV = pPlaneOut[2].pac_data + pPlaneOut[2].u_topleft; 1690 M4OSA_UInt8* pInPlaneY = NULL; 1691 M4OSA_UInt8* pInPlaneU = NULL; 1692 M4OSA_UInt8* pInPlaneV = NULL; 1693 M4OSA_UInt32 i; 1694 1695 /*to keep media aspect ratio*/ 1696 /*Initialize AIR Params*/ 1697 Params.m_inputCoord.m_x = 0; 1698 Params.m_inputCoord.m_y = 0; 1699 Params.m_inputSize.m_height = pPlaneIn->u_height; 1700 Params.m_inputSize.m_width = pPlaneIn->u_width; 1701 Params.m_outputSize.m_width = pPlaneOut->u_width; 1702 Params.m_outputSize.m_height = pPlaneOut->u_height; 1703 Params.m_bOutputStripe = M4OSA_FALSE; 1704 Params.m_outputOrientation = M4COMMON_kOrientationTopLeft; 1705 1706 /** 1707 Media rendering: Black borders*/ 1708 if(mediaRendering == M4xVSS_kBlackBorders) 1709 { 1710 memset((void *)pPlaneOut[0].pac_data,Y_PLANE_BORDER_VALUE,(pPlaneOut[0].u_height*pPlaneOut[0].u_stride)); 1711 memset((void *)pPlaneOut[1].pac_data,U_PLANE_BORDER_VALUE,(pPlaneOut[1].u_height*pPlaneOut[1].u_stride)); 1712 memset((void *)pPlaneOut[2].pac_data,V_PLANE_BORDER_VALUE,(pPlaneOut[2].u_height*pPlaneOut[2].u_stride)); 1713 1714 pImagePlanesTemp[0].u_width = pPlaneOut[0].u_width; 1715 pImagePlanesTemp[0].u_height = pPlaneOut[0].u_height; 1716 pImagePlanesTemp[0].u_stride = pPlaneOut[0].u_width; 1717 pImagePlanesTemp[0].u_topleft = 0; 1718 pImagePlanesTemp[0].pac_data = M4OSA_NULL; 1719 1720 pImagePlanesTemp[1].u_width = pPlaneOut[1].u_width; 1721 pImagePlanesTemp[1].u_height = pPlaneOut[1].u_height; 1722 pImagePlanesTemp[1].u_stride = pPlaneOut[1].u_width; 1723 pImagePlanesTemp[1].u_topleft = 0; 1724 pImagePlanesTemp[1].pac_data = M4OSA_NULL; 1725 1726 pImagePlanesTemp[2].u_width = pPlaneOut[2].u_width; 1727 pImagePlanesTemp[2].u_height = pPlaneOut[2].u_height; 1728 pImagePlanesTemp[2].u_stride = pPlaneOut[2].u_width; 1729 pImagePlanesTemp[2].u_topleft = 0; 1730 pImagePlanesTemp[2].pac_data = M4OSA_NULL; 1731 1732 /* Allocates plan in local image plane structure */ 1733 pImagePlanesTemp[0].pac_data = (M4OSA_UInt8*)M4OSA_32bitAlignedMalloc(pImagePlanesTemp[0].u_width * pImagePlanesTemp[0].u_height, M4VS, (M4OSA_Char*)"applyRenderingMode: temporary plane bufferY") ; 1734 if(pImagePlanesTemp[0].pac_data == M4OSA_NULL) 1735 { 1736 M4OSA_TRACE1_0("Error alloc in applyRenderingMode"); 1737 return M4ERR_ALLOC; 1738 } 1739 pImagePlanesTemp[1].pac_data = (M4OSA_UInt8*)M4OSA_32bitAlignedMalloc(pImagePlanesTemp[1].u_width * pImagePlanesTemp[1].u_height, M4VS, (M4OSA_Char*)"applyRenderingMode: temporary plane bufferU") ; 1740 if(pImagePlanesTemp[1].pac_data == M4OSA_NULL) 1741 { 1742 1743 M4OSA_TRACE1_0("Error alloc in applyRenderingMode"); 1744 return M4ERR_ALLOC; 1745 } 1746 pImagePlanesTemp[2].pac_data = (M4OSA_UInt8*)M4OSA_32bitAlignedMalloc(pImagePlanesTemp[2].u_width * pImagePlanesTemp[2].u_height, M4VS, (M4OSA_Char*)"applyRenderingMode: temporary plane bufferV") ; 1747 if(pImagePlanesTemp[2].pac_data == M4OSA_NULL) 1748 { 1749 1750 M4OSA_TRACE1_0("Error alloc in applyRenderingMode"); 1751 return M4ERR_ALLOC; 1752 } 1753 1754 pInPlaneY = pImagePlanesTemp[0].pac_data ; 1755 pInPlaneU = pImagePlanesTemp[1].pac_data ; 1756 pInPlaneV = pImagePlanesTemp[2].pac_data ; 1757 1758 memset((void *)pImagePlanesTemp[0].pac_data,Y_PLANE_BORDER_VALUE,(pImagePlanesTemp[0].u_height*pImagePlanesTemp[0].u_stride)); 1759 memset((void *)pImagePlanesTemp[1].pac_data,U_PLANE_BORDER_VALUE,(pImagePlanesTemp[1].u_height*pImagePlanesTemp[1].u_stride)); 1760 memset((void *)pImagePlanesTemp[2].pac_data,V_PLANE_BORDER_VALUE,(pImagePlanesTemp[2].u_height*pImagePlanesTemp[2].u_stride)); 1761 1762 if((M4OSA_UInt32)((pPlaneIn->u_height * pPlaneOut->u_width) /pPlaneIn->u_width) <= pPlaneOut->u_height)//Params.m_inputSize.m_height < Params.m_inputSize.m_width) 1763 { 1764 /*it is height so black borders will be on the top and on the bottom side*/ 1765 Params.m_outputSize.m_width = pPlaneOut->u_width; 1766 Params.m_outputSize.m_height = (M4OSA_UInt32)((pPlaneIn->u_height * pPlaneOut->u_width) /pPlaneIn->u_width); 1767 /*number of lines at the top*/ 1768 pImagePlanesTemp[0].u_topleft = (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[0].u_height-Params.m_outputSize.m_height)>>1))*pImagePlanesTemp[0].u_stride; 1769 pImagePlanesTemp[0].u_height = Params.m_outputSize.m_height; 1770 pImagePlanesTemp[1].u_topleft = (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[1].u_height-(Params.m_outputSize.m_height>>1)))>>1)*pImagePlanesTemp[1].u_stride; 1771 pImagePlanesTemp[1].u_height = Params.m_outputSize.m_height>>1; 1772 pImagePlanesTemp[2].u_topleft = (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[2].u_height-(Params.m_outputSize.m_height>>1)))>>1)*pImagePlanesTemp[2].u_stride; 1773 pImagePlanesTemp[2].u_height = Params.m_outputSize.m_height>>1; 1774 } 1775 else 1776 { 1777 /*it is width so black borders will be on the left and right side*/ 1778 Params.m_outputSize.m_height = pPlaneOut->u_height; 1779 Params.m_outputSize.m_width = (M4OSA_UInt32)((pPlaneIn->u_width * pPlaneOut->u_height) /pPlaneIn->u_height); 1780 1781 pImagePlanesTemp[0].u_topleft = (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[0].u_width-Params.m_outputSize.m_width)>>1)); 1782 pImagePlanesTemp[0].u_width = Params.m_outputSize.m_width; 1783 pImagePlanesTemp[1].u_topleft = (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[1].u_width-(Params.m_outputSize.m_width>>1)))>>1); 1784 pImagePlanesTemp[1].u_width = Params.m_outputSize.m_width>>1; 1785 pImagePlanesTemp[2].u_topleft = (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[2].u_width-(Params.m_outputSize.m_width>>1)))>>1); 1786 pImagePlanesTemp[2].u_width = Params.m_outputSize.m_width>>1; 1787 } 1788 1789 /*Width and height have to be even*/ 1790 Params.m_outputSize.m_width = (Params.m_outputSize.m_width>>1)<<1; 1791 Params.m_outputSize.m_height = (Params.m_outputSize.m_height>>1)<<1; 1792 Params.m_inputSize.m_width = (Params.m_inputSize.m_width>>1)<<1; 1793 Params.m_inputSize.m_height = (Params.m_inputSize.m_height>>1)<<1; 1794 pImagePlanesTemp[0].u_width = (pImagePlanesTemp[0].u_width>>1)<<1; 1795 pImagePlanesTemp[1].u_width = (pImagePlanesTemp[1].u_width>>1)<<1; 1796 pImagePlanesTemp[2].u_width = (pImagePlanesTemp[2].u_width>>1)<<1; 1797 pImagePlanesTemp[0].u_height = (pImagePlanesTemp[0].u_height>>1)<<1; 1798 pImagePlanesTemp[1].u_height = (pImagePlanesTemp[1].u_height>>1)<<1; 1799 pImagePlanesTemp[2].u_height = (pImagePlanesTemp[2].u_height>>1)<<1; 1800 1801 /*Check that values are coherent*/ 1802 if(Params.m_inputSize.m_height == Params.m_outputSize.m_height) 1803 { 1804 Params.m_inputSize.m_width = Params.m_outputSize.m_width; 1805 } 1806 else if(Params.m_inputSize.m_width == Params.m_outputSize.m_width) 1807 { 1808 Params.m_inputSize.m_height = Params.m_outputSize.m_height; 1809 } 1810 pPlaneTemp = pImagePlanesTemp; 1811 1812 1813 } 1814 1815 /** 1816 Media rendering: Cropping*/ 1817 if(mediaRendering == M4xVSS_kCropping) 1818 { 1819 Params.m_outputSize.m_height = pPlaneOut->u_height; 1820 Params.m_outputSize.m_width = pPlaneOut->u_width; 1821 if((Params.m_outputSize.m_height * Params.m_inputSize.m_width) /Params.m_outputSize.m_width<Params.m_inputSize.m_height) 1822 { 1823 /*height will be cropped*/ 1824 Params.m_inputSize.m_height = (M4OSA_UInt32)((Params.m_outputSize.m_height * Params.m_inputSize.m_width) /Params.m_outputSize.m_width); 1825 Params.m_inputSize.m_height = (Params.m_inputSize.m_height>>1)<<1; 1826 Params.m_inputCoord.m_y = (M4OSA_Int32)((M4OSA_Int32)((pPlaneIn->u_height - Params.m_inputSize.m_height))>>1); 1827 } 1828 else 1829 { 1830 /*width will be cropped*/ 1831 Params.m_inputSize.m_width = (M4OSA_UInt32)((Params.m_outputSize.m_width * Params.m_inputSize.m_height) /Params.m_outputSize.m_height); 1832 Params.m_inputSize.m_width = (Params.m_inputSize.m_width>>1)<<1; 1833 Params.m_inputCoord.m_x = (M4OSA_Int32)((M4OSA_Int32)((pPlaneIn->u_width - Params.m_inputSize.m_width))>>1); 1834 } 1835 pPlaneTemp = pPlaneOut; 1836 } 1837 1838 /** 1839 * Call AIR functions */ 1840 err = M4AIR_create(&m_air_context, M4AIR_kYUV420P); 1841 if(err != M4NO_ERROR) 1842 { 1843 1844 M4OSA_TRACE1_1("applyRenderingMode: Error when initializing AIR: 0x%x", err); 1845 for(i=0; i<3; i++) 1846 { 1847 if(pImagePlanesTemp[i].pac_data != M4OSA_NULL) 1848 { 1849 free(pImagePlanesTemp[i].pac_data); 1850 pImagePlanesTemp[i].pac_data = M4OSA_NULL; 1851 } 1852 } 1853 return err; 1854 } 1855 1856 1857 err = M4AIR_configure(m_air_context, &Params); 1858 if(err != M4NO_ERROR) 1859 { 1860 1861 M4OSA_TRACE1_1("applyRenderingMode: Error when configuring AIR: 0x%x", err); 1862 M4AIR_cleanUp(m_air_context); 1863 for(i=0; i<3; i++) 1864 { 1865 if(pImagePlanesTemp[i].pac_data != M4OSA_NULL) 1866 { 1867 free(pImagePlanesTemp[i].pac_data); 1868 pImagePlanesTemp[i].pac_data = M4OSA_NULL; 1869 } 1870 } 1871 return err; 1872 } 1873 1874 err = M4AIR_get(m_air_context, pPlaneIn, pPlaneTemp); 1875 if(err != M4NO_ERROR) 1876 { 1877 M4OSA_TRACE1_1("applyRenderingMode: Error when getting AIR plane: 0x%x", err); 1878 M4AIR_cleanUp(m_air_context); 1879 for(i=0; i<3; i++) 1880 { 1881 if(pImagePlanesTemp[i].pac_data != M4OSA_NULL) 1882 { 1883 free(pImagePlanesTemp[i].pac_data); 1884 pImagePlanesTemp[i].pac_data = M4OSA_NULL; 1885 } 1886 } 1887 return err; 1888 } 1889 1890 if(mediaRendering == M4xVSS_kBlackBorders) 1891 { 1892 for(i=0; i<pPlaneOut[0].u_height; i++) 1893 { 1894 memcpy((void *)pOutPlaneY, (void *)pInPlaneY, pPlaneOut[0].u_width); 1895 pInPlaneY += pPlaneOut[0].u_width; 1896 pOutPlaneY += pPlaneOut[0].u_stride; 1897 } 1898 for(i=0; i<pPlaneOut[1].u_height; i++) 1899 { 1900 memcpy((void *)pOutPlaneU, (void *)pInPlaneU, pPlaneOut[1].u_width); 1901 pInPlaneU += pPlaneOut[1].u_width; 1902 pOutPlaneU += pPlaneOut[1].u_stride; 1903 } 1904 for(i=0; i<pPlaneOut[2].u_height; i++) 1905 { 1906 memcpy((void *)pOutPlaneV, (void *)pInPlaneV, pPlaneOut[2].u_width); 1907 pInPlaneV += pPlaneOut[2].u_width; 1908 pOutPlaneV += pPlaneOut[2].u_stride; 1909 } 1910 1911 for(i=0; i<3; i++) 1912 { 1913 if(pImagePlanesTemp[i].pac_data != M4OSA_NULL) 1914 { 1915 free(pImagePlanesTemp[i].pac_data); 1916 pImagePlanesTemp[i].pac_data = M4OSA_NULL; 1917 } 1918 } 1919 } 1920 1921 if (m_air_context != M4OSA_NULL) { 1922 M4AIR_cleanUp(m_air_context); 1923 m_air_context = M4OSA_NULL; 1924 } 1925 } 1926 1927 return err; 1928 } 1929 1930 //TODO: remove this code after link with videoartist lib 1931 /* M4AIR code*/ 1932 #define M4AIR_YUV420_FORMAT_SUPPORTED 1933 #define M4AIR_YUV420A_FORMAT_SUPPORTED 1934 1935 /************************* COMPILATION CHECKS ***************************/ 1936 #ifndef M4AIR_YUV420_FORMAT_SUPPORTED 1937 #ifndef M4AIR_BGR565_FORMAT_SUPPORTED 1938 #ifndef M4AIR_RGB565_FORMAT_SUPPORTED 1939 #ifndef M4AIR_BGR888_FORMAT_SUPPORTED 1940 #ifndef M4AIR_RGB888_FORMAT_SUPPORTED 1941 #ifndef M4AIR_JPG_FORMAT_SUPPORTED 1942 1943 #error "Please define at least one input format for the AIR component" 1944 1945 #endif 1946 #endif 1947 #endif 1948 #endif 1949 #endif 1950 #endif 1951 1952 /************************ M4AIR INTERNAL TYPES DEFINITIONS ***********************/ 1953 1954 /** 1955 ****************************************************************************** 1956 * enum M4AIR_States 1957 * @brief The following enumeration defines the internal states of the AIR. 1958 ****************************************************************************** 1959 */ 1960 typedef enum 1961 { 1962 M4AIR_kCreated, /**< State after M4AIR_create has been called */ 1963 M4AIR_kConfigured /**< State after M4AIR_configure has been called */ 1964 }M4AIR_States; 1965 1966 1967 /** 1968 ****************************************************************************** 1969 * struct M4AIR_InternalContext 1970 * @brief The following structure is the internal context of the AIR. 1971 ****************************************************************************** 1972 */ 1973 typedef struct 1974 { 1975 M4AIR_States m_state; /**< Internal state */ 1976 M4AIR_InputFormatType m_inputFormat; /**< Input format like YUV420Planar, RGB565, JPG, etc ... */ 1977 M4AIR_Params m_params; /**< Current input Parameter of the processing */ 1978 M4OSA_UInt32 u32_x_inc[4]; /**< ratio between input and ouput width for YUV */ 1979 M4OSA_UInt32 u32_y_inc[4]; /**< ratio between input and ouput height for YUV */ 1980 M4OSA_UInt32 u32_x_accum_start[4]; /**< horizontal initial accumulator value */ 1981 M4OSA_UInt32 u32_y_accum_start[4]; /**< Vertical initial accumulator value */ 1982 M4OSA_UInt32 u32_x_accum[4]; /**< save of horizontal accumulator value */ 1983 M4OSA_UInt32 u32_y_accum[4]; /**< save of vertical accumulator value */ 1984 M4OSA_UInt8* pu8_data_in[4]; /**< Save of input plane pointers in case of stripe mode */ 1985 M4OSA_UInt32 m_procRows; /**< Number of processed rows, used in stripe mode only */ 1986 M4OSA_Bool m_bOnlyCopy; /**< Flag to know if we just perform a copy or a bilinear interpolation */ 1987 M4OSA_Bool m_bFlipX; /**< Depend on output orientation, used during processing to revert processing order in X coordinates */ 1988 M4OSA_Bool m_bFlipY; /**< Depend on output orientation, used during processing to revert processing order in Y coordinates */ 1989 M4OSA_Bool m_bRevertXY; /**< Depend on output orientation, used during processing to revert X and Y processing order (+-90 rotation) */ 1990 }M4AIR_InternalContext; 1991 1992 /********************************* MACROS *******************************/ 1993 #define M4ERR_CHECK_NULL_RETURN_VALUE(retval, pointer) if ((pointer) == M4OSA_NULL) return ((M4OSA_ERR)(retval)); 1994 1995 1996 /********************** M4AIR PUBLIC API IMPLEMENTATION ********************/ 1997 /** 1998 ****************************************************************************** 1999 * M4OSA_ERR M4AIR_create(M4OSA_Context* pContext,M4AIR_InputFormatType inputFormat) 2000 * @author Arnaud Collard 2001 * @brief This function initialize an instance of the AIR. 2002 * @param pContext: (IN/OUT) Address of the context to create 2003 * @param inputFormat: (IN) input format type. 2004 * @return M4NO_ERROR: there is no error 2005 * @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only). Invalid formatType 2006 * @return M4ERR_ALLOC: No more memory is available 2007 ****************************************************************************** 2008 */ 2009 M4OSA_ERR M4AIR_create(M4OSA_Context* pContext,M4AIR_InputFormatType inputFormat) 2010 { 2011 M4OSA_ERR err = M4NO_ERROR ; 2012 M4AIR_InternalContext* pC = M4OSA_NULL ; 2013 /* Check that the address on the context is not NULL */ 2014 M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pContext) ; 2015 2016 *pContext = M4OSA_NULL ; 2017 2018 /* Internal Context creation */ 2019 pC = (M4AIR_InternalContext*)M4OSA_32bitAlignedMalloc(sizeof(M4AIR_InternalContext), M4AIR, (M4OSA_Char*)"AIR internal context") ; 2020 M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_ALLOC, pC) ; 2021 2022 2023 /* Check if the input format is supported */ 2024 switch(inputFormat) 2025 { 2026 #ifdef M4AIR_YUV420_FORMAT_SUPPORTED 2027 case M4AIR_kYUV420P: 2028 break ; 2029 #endif 2030 #ifdef M4AIR_YUV420A_FORMAT_SUPPORTED 2031 case M4AIR_kYUV420AP: 2032 break ; 2033 #endif 2034 default: 2035 err = M4ERR_AIR_FORMAT_NOT_SUPPORTED; 2036 goto M4AIR_create_cleanup ; 2037 } 2038 2039 /**< Save input format and update state */ 2040 pC->m_inputFormat = inputFormat; 2041 pC->m_state = M4AIR_kCreated; 2042 2043 /* Return the context to the caller */ 2044 *pContext = pC ; 2045 2046 return M4NO_ERROR ; 2047 2048 M4AIR_create_cleanup: 2049 /* Error management : we destroy the context if needed */ 2050 if(M4OSA_NULL != pC) 2051 { 2052 free(pC) ; 2053 } 2054 2055 *pContext = M4OSA_NULL ; 2056 2057 return err ; 2058 } 2059 2060 2061 2062 /** 2063 ****************************************************************************** 2064 * M4OSA_ERR M4AIR_cleanUp(M4OSA_Context pContext) 2065 * @author Arnaud Collard 2066 * @brief This function destroys an instance of the AIR component 2067 * @param pContext: (IN) Context identifying the instance to destroy 2068 * @return M4NO_ERROR: there is no error 2069 * @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only). 2070 * @return M4ERR_STATE: Internal state is incompatible with this function call. 2071 ****************************************************************************** 2072 */ 2073 M4OSA_ERR M4AIR_cleanUp(M4OSA_Context pContext) 2074 { 2075 M4AIR_InternalContext* pC = (M4AIR_InternalContext*)pContext ; 2076 2077 M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pContext) ; 2078 2079 /**< Check state */ 2080 if((M4AIR_kCreated != pC->m_state)&&(M4AIR_kConfigured != pC->m_state)) 2081 { 2082 return M4ERR_STATE; 2083 } 2084 free(pC) ; 2085 2086 return M4NO_ERROR ; 2087 2088 } 2089 2090 2091 /** 2092 ****************************************************************************** 2093 * M4OSA_ERR M4AIR_configure(M4OSA_Context pContext, M4AIR_Params* pParams) 2094 * @brief This function will configure the AIR. 2095 * @note It will set the input and output coordinates and sizes, 2096 * and indicates if we will proceed in stripe or not. 2097 * In case a M4AIR_get in stripe mode was on going, it will cancel this previous processing 2098 * and reset the get process. 2099 * @param pContext: (IN) Context identifying the instance 2100 * @param pParams->m_bOutputStripe:(IN) Stripe mode. 2101 * @param pParams->m_inputCoord: (IN) X,Y coordinates of the first valid pixel in input. 2102 * @param pParams->m_inputSize: (IN) input ROI size. 2103 * @param pParams->m_outputSize: (IN) output size. 2104 * @return M4NO_ERROR: there is no error 2105 * @return M4ERR_ALLOC: No more memory space to add a new effect. 2106 * @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only). 2107 * @return M4ERR_AIR_FORMAT_NOT_SUPPORTED: the requested input format is not supported. 2108 ****************************************************************************** 2109 */ 2110 M4OSA_ERR M4AIR_configure(M4OSA_Context pContext, M4AIR_Params* pParams) 2111 { 2112 M4AIR_InternalContext* pC = (M4AIR_InternalContext*)pContext ; 2113 M4OSA_UInt32 i,u32_width_in, u32_width_out, u32_height_in, u32_height_out; 2114 M4OSA_UInt32 nb_planes; 2115 2116 M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pContext) ; 2117 2118 if(M4AIR_kYUV420AP == pC->m_inputFormat) 2119 { 2120 nb_planes = 4; 2121 } 2122 else 2123 { 2124 nb_planes = 3; 2125 } 2126 2127 /**< Check state */ 2128 if((M4AIR_kCreated != pC->m_state)&&(M4AIR_kConfigured != pC->m_state)) 2129 { 2130 return M4ERR_STATE; 2131 } 2132 2133 /** Save parameters */ 2134 pC->m_params = *pParams; 2135 2136 /* Check for the input&output width and height are even */ 2137 if( ((pC->m_params.m_inputSize.m_height)&0x1) || 2138 ((pC->m_params.m_inputSize.m_height)&0x1)) 2139 { 2140 return M4ERR_AIR_ILLEGAL_FRAME_SIZE; 2141 } 2142 2143 if( ((pC->m_params.m_inputSize.m_width)&0x1) || 2144 ((pC->m_params.m_inputSize.m_width)&0x1)) 2145 { 2146 return M4ERR_AIR_ILLEGAL_FRAME_SIZE; 2147 } 2148 if(((pC->m_params.m_inputSize.m_width) == (pC->m_params.m_outputSize.m_width)) 2149 &&((pC->m_params.m_inputSize.m_height) == (pC->m_params.m_outputSize.m_height))) 2150 { 2151 /**< No resize in this case, we will just copy input in output */ 2152 pC->m_bOnlyCopy = M4OSA_TRUE; 2153 } 2154 else 2155 { 2156 pC->m_bOnlyCopy = M4OSA_FALSE; 2157 2158 /**< Initialize internal variables used for resize filter */ 2159 for(i=0;i<nb_planes;i++) 2160 { 2161 2162 u32_width_in = ((i==0)||(i==3))?pC->m_params.m_inputSize.m_width:(pC->m_params.m_inputSize.m_width+1)>>1; 2163 u32_height_in = ((i==0)||(i==3))?pC->m_params.m_inputSize.m_height:(pC->m_params.m_inputSize.m_height+1)>>1; 2164 u32_width_out = ((i==0)||(i==3))?pC->m_params.m_outputSize.m_width:(pC->m_params.m_outputSize.m_width+1)>>1; 2165 u32_height_out = ((i==0)||(i==3))?pC->m_params.m_outputSize.m_height:(pC->m_params.m_outputSize.m_height+1)>>1; 2166 2167 /* Compute horizontal ratio between src and destination width.*/ 2168 if (u32_width_out >= u32_width_in) 2169 { 2170 pC->u32_x_inc[i] = ((u32_width_in-1) * 0x10000) / (u32_width_out-1); 2171 } 2172 else 2173 { 2174 pC->u32_x_inc[i] = (u32_width_in * 0x10000) / (u32_width_out); 2175 } 2176 2177 /* Compute vertical ratio between src and destination height.*/ 2178 if (u32_height_out >= u32_height_in) 2179 { 2180 pC->u32_y_inc[i] = ((u32_height_in - 1) * 0x10000) / (u32_height_out-1); 2181 } 2182 else 2183 { 2184 pC->u32_y_inc[i] = (u32_height_in * 0x10000) / (u32_height_out); 2185 } 2186 2187 /* 2188 Calculate initial accumulator value : u32_y_accum_start. 2189 u32_y_accum_start is coded on 15 bits, and represents a value between 0 and 0.5 2190 */ 2191 if (pC->u32_y_inc[i] >= 0x10000) 2192 { 2193 /* 2194 Keep the fractionnal part, assimung that integer part is coded 2195 on the 16 high bits and the fractionnal on the 15 low bits 2196 */ 2197 pC->u32_y_accum_start[i] = pC->u32_y_inc[i] & 0xffff; 2198 2199 if (!pC->u32_y_accum_start[i]) 2200 { 2201 pC->u32_y_accum_start[i] = 0x10000; 2202 } 2203 2204 pC->u32_y_accum_start[i] >>= 1; 2205 } 2206 else 2207 { 2208 pC->u32_y_accum_start[i] = 0; 2209 } 2210 /**< Take into account that Y coordinate can be odd 2211 in this case we have to put a 0.5 offset 2212 for U and V plane as there a 2 times sub-sampled vs Y*/ 2213 if((pC->m_params.m_inputCoord.m_y&0x1)&&((i==1)||(i==2))) 2214 { 2215 pC->u32_y_accum_start[i] += 0x8000; 2216 } 2217 2218 /* 2219 Calculate initial accumulator value : u32_x_accum_start. 2220 u32_x_accum_start is coded on 15 bits, and represents a value between 0 and 0.5 2221 */ 2222 2223 if (pC->u32_x_inc[i] >= 0x10000) 2224 { 2225 pC->u32_x_accum_start[i] = pC->u32_x_inc[i] & 0xffff; 2226 2227 if (!pC->u32_x_accum_start[i]) 2228 { 2229 pC->u32_x_accum_start[i] = 0x10000; 2230 } 2231 2232 pC->u32_x_accum_start[i] >>= 1; 2233 } 2234 else 2235 { 2236 pC->u32_x_accum_start[i] = 0; 2237 } 2238 /**< Take into account that X coordinate can be odd 2239 in this case we have to put a 0.5 offset 2240 for U and V plane as there a 2 times sub-sampled vs Y*/ 2241 if((pC->m_params.m_inputCoord.m_x&0x1)&&((i==1)||(i==2))) 2242 { 2243 pC->u32_x_accum_start[i] += 0x8000; 2244 } 2245 } 2246 } 2247 2248 /**< Reset variable used for stripe mode */ 2249 pC->m_procRows = 0; 2250 2251 /**< Initialize var for X/Y processing order according to orientation */ 2252 pC->m_bFlipX = M4OSA_FALSE; 2253 pC->m_bFlipY = M4OSA_FALSE; 2254 pC->m_bRevertXY = M4OSA_FALSE; 2255 switch(pParams->m_outputOrientation) 2256 { 2257 case M4COMMON_kOrientationTopLeft: 2258 break; 2259 case M4COMMON_kOrientationTopRight: 2260 pC->m_bFlipX = M4OSA_TRUE; 2261 break; 2262 case M4COMMON_kOrientationBottomRight: 2263 pC->m_bFlipX = M4OSA_TRUE; 2264 pC->m_bFlipY = M4OSA_TRUE; 2265 break; 2266 case M4COMMON_kOrientationBottomLeft: 2267 pC->m_bFlipY = M4OSA_TRUE; 2268 break; 2269 case M4COMMON_kOrientationLeftTop: 2270 pC->m_bRevertXY = M4OSA_TRUE; 2271 break; 2272 case M4COMMON_kOrientationRightTop: 2273 pC->m_bRevertXY = M4OSA_TRUE; 2274 pC->m_bFlipY = M4OSA_TRUE; 2275 break; 2276 case M4COMMON_kOrientationRightBottom: 2277 pC->m_bRevertXY = M4OSA_TRUE; 2278 pC->m_bFlipX = M4OSA_TRUE; 2279 pC->m_bFlipY = M4OSA_TRUE; 2280 break; 2281 case M4COMMON_kOrientationLeftBottom: 2282 pC->m_bRevertXY = M4OSA_TRUE; 2283 pC->m_bFlipX = M4OSA_TRUE; 2284 break; 2285 default: 2286 return M4ERR_PARAMETER; 2287 } 2288 /**< Update state */ 2289 pC->m_state = M4AIR_kConfigured; 2290 2291 return M4NO_ERROR ; 2292 } 2293 2294 2295 /** 2296 ****************************************************************************** 2297 * M4OSA_ERR M4AIR_get(M4OSA_Context pContext, M4VIFI_ImagePlane* pIn, M4VIFI_ImagePlane* pOut) 2298 * @brief This function will provide the requested resized area of interest according to settings 2299 * provided in M4AIR_configure. 2300 * @note In case the input format type is JPEG, input plane(s) 2301 * in pIn is not used. In normal mode, dimension specified in output plane(s) structure must be the 2302 * same than the one specified in M4AIR_configure. In stripe mode, only the width will be the same, 2303 * height will be taken as the stripe height (typically 16). 2304 * In normal mode, this function is call once to get the full output picture. In stripe mode, it is called 2305 * for each stripe till the whole picture has been retrieved,and the position of the output stripe in the output picture 2306 * is internally incremented at each step. 2307 * Any call to M4AIR_configure during stripe process will reset this one to the beginning of the output picture. 2308 * @param pContext: (IN) Context identifying the instance 2309 * @param pIn: (IN) Plane structure containing input Plane(s). 2310 * @param pOut: (IN/OUT) Plane structure containing output Plane(s). 2311 * @return M4NO_ERROR: there is no error 2312 * @return M4ERR_ALLOC: No more memory space to add a new effect. 2313 * @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only). 2314 ****************************************************************************** 2315 */ 2316 M4OSA_ERR M4AIR_get(M4OSA_Context pContext, M4VIFI_ImagePlane* pIn, M4VIFI_ImagePlane* pOut) 2317 { 2318 M4AIR_InternalContext* pC = (M4AIR_InternalContext*)pContext ; 2319 M4OSA_UInt32 i,j,k,u32_x_frac,u32_y_frac,u32_x_accum,u32_y_accum,u32_shift; 2320 M4OSA_UInt8 *pu8_data_in, *pu8_data_in_org, *pu8_data_in_tmp, *pu8_data_out; 2321 M4OSA_UInt8 *pu8_src_top; 2322 M4OSA_UInt8 *pu8_src_bottom; 2323 M4OSA_UInt32 u32_temp_value; 2324 M4OSA_Int32 i32_tmp_offset; 2325 M4OSA_UInt32 nb_planes; 2326 2327 2328 2329 M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pContext) ; 2330 2331 /**< Check state */ 2332 if(M4AIR_kConfigured != pC->m_state) 2333 { 2334 return M4ERR_STATE; 2335 } 2336 2337 if(M4AIR_kYUV420AP == pC->m_inputFormat) 2338 { 2339 nb_planes = 4; 2340 } 2341 else 2342 { 2343 nb_planes = 3; 2344 } 2345 2346 /**< Loop on each Plane */ 2347 for(i=0;i<nb_planes;i++) 2348 { 2349 2350 /* Set the working pointers at the beginning of the input/output data field */ 2351 2352 u32_shift = ((i==0)||(i==3))?0:1; /**< Depend on Luma or Chroma */ 2353 2354 if((M4OSA_FALSE == pC->m_params.m_bOutputStripe)||((M4OSA_TRUE == pC->m_params.m_bOutputStripe)&&(0 == pC->m_procRows))) 2355 { 2356 /**< For input, take care about ROI */ 2357 pu8_data_in = pIn[i].pac_data + pIn[i].u_topleft + (pC->m_params.m_inputCoord.m_x>>u32_shift) 2358 + (pC->m_params.m_inputCoord.m_y >> u32_shift) * pIn[i].u_stride; 2359 2360 /** Go at end of line/column in case X/Y scanning is flipped */ 2361 if(M4OSA_TRUE == pC->m_bFlipX) 2362 { 2363 pu8_data_in += ((pC->m_params.m_inputSize.m_width)>>u32_shift) -1 ; 2364 } 2365 if(M4OSA_TRUE == pC->m_bFlipY) 2366 { 2367 pu8_data_in += ((pC->m_params.m_inputSize.m_height>>u32_shift) -1) * pIn[i].u_stride; 2368 } 2369 2370 /**< Initialize accumulators in case we are using it (bilinear interpolation) */ 2371 if( M4OSA_FALSE == pC->m_bOnlyCopy) 2372 { 2373 pC->u32_x_accum[i] = pC->u32_x_accum_start[i]; 2374 pC->u32_y_accum[i] = pC->u32_y_accum_start[i]; 2375 } 2376 2377 } 2378 else 2379 { 2380 /**< In case of stripe mode for other than first stripe, we need to recover input pointer from internal context */ 2381 pu8_data_in = pC->pu8_data_in[i]; 2382 } 2383 2384 /**< In every mode, output data are at the beginning of the output plane */ 2385 pu8_data_out = pOut[i].pac_data + pOut[i].u_topleft; 2386 2387 /**< Initialize input offset applied after each pixel */ 2388 if(M4OSA_FALSE == pC->m_bFlipY) 2389 { 2390 i32_tmp_offset = pIn[i].u_stride; 2391 } 2392 else 2393 { 2394 i32_tmp_offset = -pIn[i].u_stride; 2395 } 2396 2397 /**< In this case, no bilinear interpolation is needed as input and output dimensions are the same */ 2398 if( M4OSA_TRUE == pC->m_bOnlyCopy) 2399 { 2400 /**< No +-90 rotation */ 2401 if(M4OSA_FALSE == pC->m_bRevertXY) 2402 { 2403 /**< No flip on X abscissa */ 2404 if(M4OSA_FALSE == pC->m_bFlipX) 2405 { 2406 M4OSA_UInt32 loc_height = pOut[i].u_height; 2407 M4OSA_UInt32 loc_width = pOut[i].u_width; 2408 M4OSA_UInt32 loc_stride = pIn[i].u_stride; 2409 /**< Loop on each row */ 2410 for (j=0; j<loc_height; j++) 2411 { 2412 /**< Copy one whole line */ 2413 memcpy((void *)pu8_data_out, (void *)pu8_data_in, loc_width); 2414 2415 /**< Update pointers */ 2416 pu8_data_out += pOut[i].u_stride; 2417 if(M4OSA_FALSE == pC->m_bFlipY) 2418 { 2419 pu8_data_in += loc_stride; 2420 } 2421 else 2422 { 2423 pu8_data_in -= loc_stride; 2424 } 2425 } 2426 } 2427 else 2428 { 2429 /**< Loop on each row */ 2430 for(j=0;j<pOut[i].u_height;j++) 2431 { 2432 /**< Loop on each pixel of 1 row */ 2433 for(k=0;k<pOut[i].u_width;k++) 2434 { 2435 *pu8_data_out++ = *pu8_data_in--; 2436 } 2437 2438 /**< Update pointers */ 2439 pu8_data_out += (pOut[i].u_stride - pOut[i].u_width); 2440 2441 pu8_data_in += pOut[i].u_width + i32_tmp_offset; 2442 2443 } 2444 } 2445 } 2446 /**< Here we have a +-90 rotation */ 2447 else 2448 { 2449 2450 /**< Loop on each row */ 2451 for(j=0;j<pOut[i].u_height;j++) 2452 { 2453 pu8_data_in_tmp = pu8_data_in; 2454 2455 /**< Loop on each pixel of 1 row */ 2456 for(k=0;k<pOut[i].u_width;k++) 2457 { 2458 *pu8_data_out++ = *pu8_data_in_tmp; 2459 2460 /**< Update input pointer in order to go to next/past line */ 2461 pu8_data_in_tmp += i32_tmp_offset; 2462 } 2463 2464 /**< Update pointers */ 2465 pu8_data_out += (pOut[i].u_stride - pOut[i].u_width); 2466 if(M4OSA_FALSE == pC->m_bFlipX) 2467 { 2468 pu8_data_in ++; 2469 } 2470 else 2471 { 2472 pu8_data_in --; 2473 } 2474 } 2475 } 2476 } 2477 /**< Bilinear interpolation */ 2478 else 2479 { 2480 2481 if(3 != i) /**< other than alpha plane */ 2482 { 2483 /**No +-90 rotation */ 2484 if(M4OSA_FALSE == pC->m_bRevertXY) 2485 { 2486 2487 /**< Loop on each row */ 2488 for(j=0;j<pOut[i].u_height;j++) 2489 { 2490 /* Vertical weight factor */ 2491 u32_y_frac = (pC->u32_y_accum[i]>>12)&15; 2492 2493 /* Reinit horizontal weight factor */ 2494 u32_x_accum = pC->u32_x_accum_start[i]; 2495 2496 2497 2498 if(M4OSA_TRUE == pC->m_bFlipX) 2499 { 2500 2501 /**< Loop on each output pixel in a row */ 2502 for(k=0;k<pOut[i].u_width;k++) 2503 { 2504 2505 u32_x_frac = (u32_x_accum >> 12)&15; /* Fraction of Horizontal weight factor */ 2506 2507 pu8_src_top = (pu8_data_in - (u32_x_accum >> 16)) -1 ; 2508 2509 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 2510 2511 /* Weighted combination */ 2512 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[1]*(16-u32_x_frac) + 2513 pu8_src_top[0]*u32_x_frac)*(16-u32_y_frac) + 2514 (pu8_src_bottom[1]*(16-u32_x_frac) + 2515 pu8_src_bottom[0]*u32_x_frac)*u32_y_frac )>>8); 2516 2517 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 2518 2519 /* Update horizontal accumulator */ 2520 u32_x_accum += pC->u32_x_inc[i]; 2521 } 2522 } 2523 2524 else 2525 { 2526 /**< Loop on each output pixel in a row */ 2527 for(k=0;k<pOut[i].u_width;k++) 2528 { 2529 u32_x_frac = (u32_x_accum >> 12)&15; /* Fraction of Horizontal weight factor */ 2530 2531 pu8_src_top = pu8_data_in + (u32_x_accum >> 16); 2532 2533 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 2534 2535 /* Weighted combination */ 2536 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[0]*(16-u32_x_frac) + 2537 pu8_src_top[1]*u32_x_frac)*(16-u32_y_frac) + 2538 (pu8_src_bottom[0]*(16-u32_x_frac) + 2539 pu8_src_bottom[1]*u32_x_frac)*u32_y_frac )>>8); 2540 2541 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 2542 2543 /* Update horizontal accumulator */ 2544 u32_x_accum += pC->u32_x_inc[i]; 2545 } 2546 2547 } 2548 2549 pu8_data_out += pOut[i].u_stride - pOut[i].u_width; 2550 2551 /* Update vertical accumulator */ 2552 pC->u32_y_accum[i] += pC->u32_y_inc[i]; 2553 if (pC->u32_y_accum[i]>>16) 2554 { 2555 pu8_data_in = pu8_data_in + (pC->u32_y_accum[i] >> 16) * i32_tmp_offset; 2556 pC->u32_y_accum[i] &= 0xffff; 2557 } 2558 } 2559 } 2560 /** +-90 rotation */ 2561 else 2562 { 2563 pu8_data_in_org = pu8_data_in; 2564 2565 /**< Loop on each output row */ 2566 for(j=0;j<pOut[i].u_height;j++) 2567 { 2568 /* horizontal weight factor */ 2569 u32_x_frac = (pC->u32_x_accum[i]>>12)&15; 2570 2571 /* Reinit accumulator */ 2572 u32_y_accum = pC->u32_y_accum_start[i]; 2573 2574 if(M4OSA_TRUE == pC->m_bFlipX) 2575 { 2576 2577 /**< Loop on each output pixel in a row */ 2578 for(k=0;k<pOut[i].u_width;k++) 2579 { 2580 2581 u32_y_frac = (u32_y_accum >> 12)&15; /* Vertical weight factor */ 2582 2583 2584 pu8_src_top = (pu8_data_in - (pC->u32_x_accum[i] >> 16)) - 1; 2585 2586 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 2587 2588 /* Weighted combination */ 2589 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[1]*(16-u32_x_frac) + 2590 pu8_src_top[0]*u32_x_frac)*(16-u32_y_frac) + 2591 (pu8_src_bottom[1]*(16-u32_x_frac) + 2592 pu8_src_bottom[0]*u32_x_frac)*u32_y_frac )>>8); 2593 2594 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 2595 2596 /* Update vertical accumulator */ 2597 u32_y_accum += pC->u32_y_inc[i]; 2598 if (u32_y_accum>>16) 2599 { 2600 pu8_data_in = pu8_data_in + (u32_y_accum >> 16) * i32_tmp_offset; 2601 u32_y_accum &= 0xffff; 2602 } 2603 2604 } 2605 } 2606 else 2607 { 2608 /**< Loop on each output pixel in a row */ 2609 for(k=0;k<pOut[i].u_width;k++) 2610 { 2611 2612 u32_y_frac = (u32_y_accum >> 12)&15; /* Vertical weight factor */ 2613 2614 pu8_src_top = pu8_data_in + (pC->u32_x_accum[i] >> 16); 2615 2616 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 2617 2618 /* Weighted combination */ 2619 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[0]*(16-u32_x_frac) + 2620 pu8_src_top[1]*u32_x_frac)*(16-u32_y_frac) + 2621 (pu8_src_bottom[0]*(16-u32_x_frac) + 2622 pu8_src_bottom[1]*u32_x_frac)*u32_y_frac )>>8); 2623 2624 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 2625 2626 /* Update vertical accumulator */ 2627 u32_y_accum += pC->u32_y_inc[i]; 2628 if (u32_y_accum>>16) 2629 { 2630 pu8_data_in = pu8_data_in + (u32_y_accum >> 16) * i32_tmp_offset; 2631 u32_y_accum &= 0xffff; 2632 } 2633 } 2634 } 2635 pu8_data_out += pOut[i].u_stride - pOut[i].u_width; 2636 2637 /* Update horizontal accumulator */ 2638 pC->u32_x_accum[i] += pC->u32_x_inc[i]; 2639 2640 pu8_data_in = pu8_data_in_org; 2641 } 2642 2643 } 2644 }/** 3 != i */ 2645 else 2646 { 2647 /**No +-90 rotation */ 2648 if(M4OSA_FALSE == pC->m_bRevertXY) 2649 { 2650 2651 /**< Loop on each row */ 2652 for(j=0;j<pOut[i].u_height;j++) 2653 { 2654 /* Vertical weight factor */ 2655 u32_y_frac = (pC->u32_y_accum[i]>>12)&15; 2656 2657 /* Reinit horizontal weight factor */ 2658 u32_x_accum = pC->u32_x_accum_start[i]; 2659 2660 2661 2662 if(M4OSA_TRUE == pC->m_bFlipX) 2663 { 2664 2665 /**< Loop on each output pixel in a row */ 2666 for(k=0;k<pOut[i].u_width;k++) 2667 { 2668 2669 u32_x_frac = (u32_x_accum >> 12)&15; /* Fraction of Horizontal weight factor */ 2670 2671 pu8_src_top = (pu8_data_in - (u32_x_accum >> 16)) -1 ; 2672 2673 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 2674 2675 /* Weighted combination */ 2676 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[1]*(16-u32_x_frac) + 2677 pu8_src_top[0]*u32_x_frac)*(16-u32_y_frac) + 2678 (pu8_src_bottom[1]*(16-u32_x_frac) + 2679 pu8_src_bottom[0]*u32_x_frac)*u32_y_frac )>>8); 2680 2681 u32_temp_value= (u32_temp_value >> 7)*0xff; 2682 2683 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 2684 2685 /* Update horizontal accumulator */ 2686 u32_x_accum += pC->u32_x_inc[i]; 2687 } 2688 } 2689 2690 else 2691 { 2692 /**< Loop on each output pixel in a row */ 2693 for(k=0;k<pOut[i].u_width;k++) 2694 { 2695 u32_x_frac = (u32_x_accum >> 12)&15; /* Fraction of Horizontal weight factor */ 2696 2697 pu8_src_top = pu8_data_in + (u32_x_accum >> 16); 2698 2699 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 2700 2701 /* Weighted combination */ 2702 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[0]*(16-u32_x_frac) + 2703 pu8_src_top[1]*u32_x_frac)*(16-u32_y_frac) + 2704 (pu8_src_bottom[0]*(16-u32_x_frac) + 2705 pu8_src_bottom[1]*u32_x_frac)*u32_y_frac )>>8); 2706 2707 u32_temp_value= (u32_temp_value >> 7)*0xff; 2708 2709 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 2710 2711 /* Update horizontal accumulator */ 2712 u32_x_accum += pC->u32_x_inc[i]; 2713 } 2714 2715 } 2716 2717 pu8_data_out += pOut[i].u_stride - pOut[i].u_width; 2718 2719 /* Update vertical accumulator */ 2720 pC->u32_y_accum[i] += pC->u32_y_inc[i]; 2721 if (pC->u32_y_accum[i]>>16) 2722 { 2723 pu8_data_in = pu8_data_in + (pC->u32_y_accum[i] >> 16) * i32_tmp_offset; 2724 pC->u32_y_accum[i] &= 0xffff; 2725 } 2726 } 2727 2728 } /**< M4OSA_FALSE == pC->m_bRevertXY */ 2729 /** +-90 rotation */ 2730 else 2731 { 2732 pu8_data_in_org = pu8_data_in; 2733 2734 /**< Loop on each output row */ 2735 for(j=0;j<pOut[i].u_height;j++) 2736 { 2737 /* horizontal weight factor */ 2738 u32_x_frac = (pC->u32_x_accum[i]>>12)&15; 2739 2740 /* Reinit accumulator */ 2741 u32_y_accum = pC->u32_y_accum_start[i]; 2742 2743 if(M4OSA_TRUE == pC->m_bFlipX) 2744 { 2745 2746 /**< Loop on each output pixel in a row */ 2747 for(k=0;k<pOut[i].u_width;k++) 2748 { 2749 2750 u32_y_frac = (u32_y_accum >> 12)&15; /* Vertical weight factor */ 2751 2752 2753 pu8_src_top = (pu8_data_in - (pC->u32_x_accum[i] >> 16)) - 1; 2754 2755 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 2756 2757 /* Weighted combination */ 2758 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[1]*(16-u32_x_frac) + 2759 pu8_src_top[0]*u32_x_frac)*(16-u32_y_frac) + 2760 (pu8_src_bottom[1]*(16-u32_x_frac) + 2761 pu8_src_bottom[0]*u32_x_frac)*u32_y_frac )>>8); 2762 2763 u32_temp_value= (u32_temp_value >> 7)*0xff; 2764 2765 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 2766 2767 /* Update vertical accumulator */ 2768 u32_y_accum += pC->u32_y_inc[i]; 2769 if (u32_y_accum>>16) 2770 { 2771 pu8_data_in = pu8_data_in + (u32_y_accum >> 16) * i32_tmp_offset; 2772 u32_y_accum &= 0xffff; 2773 } 2774 2775 } 2776 } 2777 else 2778 { 2779 /**< Loop on each output pixel in a row */ 2780 for(k=0;k<pOut[i].u_width;k++) 2781 { 2782 2783 u32_y_frac = (u32_y_accum >> 12)&15; /* Vertical weight factor */ 2784 2785 pu8_src_top = pu8_data_in + (pC->u32_x_accum[i] >> 16); 2786 2787 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 2788 2789 /* Weighted combination */ 2790 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[0]*(16-u32_x_frac) + 2791 pu8_src_top[1]*u32_x_frac)*(16-u32_y_frac) + 2792 (pu8_src_bottom[0]*(16-u32_x_frac) + 2793 pu8_src_bottom[1]*u32_x_frac)*u32_y_frac )>>8); 2794 2795 u32_temp_value= (u32_temp_value >> 7)*0xff; 2796 2797 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 2798 2799 /* Update vertical accumulator */ 2800 u32_y_accum += pC->u32_y_inc[i]; 2801 if (u32_y_accum>>16) 2802 { 2803 pu8_data_in = pu8_data_in + (u32_y_accum >> 16) * i32_tmp_offset; 2804 u32_y_accum &= 0xffff; 2805 } 2806 } 2807 } 2808 pu8_data_out += pOut[i].u_stride - pOut[i].u_width; 2809 2810 /* Update horizontal accumulator */ 2811 pC->u32_x_accum[i] += pC->u32_x_inc[i]; 2812 2813 pu8_data_in = pu8_data_in_org; 2814 2815 } 2816 } /**< M4OSA_TRUE == pC->m_bRevertXY */ 2817 }/** 3 == i */ 2818 } 2819 /**< In case of stripe mode, save current input pointer */ 2820 if(M4OSA_TRUE == pC->m_params.m_bOutputStripe) 2821 { 2822 pC->pu8_data_in[i] = pu8_data_in; 2823 } 2824 } 2825 2826 /**< Update number of processed rows, reset it if we have finished with the whole processing */ 2827 pC->m_procRows += pOut[0].u_height; 2828 if(M4OSA_FALSE == pC->m_bRevertXY) 2829 { 2830 if(pC->m_params.m_outputSize.m_height <= pC->m_procRows) pC->m_procRows = 0; 2831 } 2832 else 2833 { 2834 if(pC->m_params.m_outputSize.m_width <= pC->m_procRows) pC->m_procRows = 0; 2835 } 2836 2837 return M4NO_ERROR ; 2838 2839 } 2840 /*+ Handle the image files here */ 2841 2842 /** 2843 ****************************************************************************** 2844 * M4OSA_ERR LvGetImageThumbNail(M4OSA_UChar *fileName, M4OSA_Void **pBuffer) 2845 * @brief This function gives YUV420 buffer of a given image file (in argb888 format) 2846 * @Note: The caller of the function is responsible to free the yuv buffer allocated 2847 * @param fileName: (IN) Path to the filename of the image argb data 2848 * @param height: (IN) Height of the image 2849 * @param width: (OUT) pBuffer pointer to the address where the yuv data address needs to be returned. 2850 * @return M4NO_ERROR: there is no error 2851 * @return M4ERR_ALLOC: No more memory space to add a new effect. 2852 * @return M4ERR_FILE_NOT_FOUND: if the file passed does not exists. 2853 ****************************************************************************** 2854 */ 2855 M4OSA_ERR LvGetImageThumbNail(const char *fileName, M4OSA_UInt32 height, M4OSA_UInt32 width, M4OSA_Void **pBuffer) { 2856 2857 M4VIFI_ImagePlane rgbPlane, *yuvPlane; 2858 M4OSA_UInt32 frameSize_argb = (width * height * 4); // argb data 2859 M4OSA_Context lImageFileFp = M4OSA_NULL; 2860 M4OSA_ERR err = M4NO_ERROR; 2861 2862 M4OSA_UInt8 *pTmpData = (M4OSA_UInt8*) M4OSA_32bitAlignedMalloc(frameSize_argb, M4VS, (M4OSA_Char*)"Image argb data"); 2863 if(pTmpData == M4OSA_NULL) { 2864 ALOGE("Failed to allocate memory for Image clip"); 2865 return M4ERR_ALLOC; 2866 } 2867 2868 /** Read the argb data from the passed file. */ 2869 M4OSA_ERR lerr = M4OSA_fileReadOpen(&lImageFileFp, (M4OSA_Void *) fileName, M4OSA_kFileRead); 2870 2871 if((lerr != M4NO_ERROR) || (lImageFileFp == M4OSA_NULL)) 2872 { 2873 ALOGE("LVPreviewController: Can not open the file "); 2874 free(pTmpData); 2875 return M4ERR_FILE_NOT_FOUND; 2876 } 2877 lerr = M4OSA_fileReadData(lImageFileFp, (M4OSA_MemAddr8)pTmpData, &frameSize_argb); 2878 if(lerr != M4NO_ERROR) 2879 { 2880 ALOGE("LVPreviewController: can not read the data "); 2881 M4OSA_fileReadClose(lImageFileFp); 2882 free(pTmpData); 2883 return lerr; 2884 } 2885 M4OSA_fileReadClose(lImageFileFp); 2886 2887 M4OSA_UInt32 frameSize = (width * height * 3); //Size of YUV420 data. 2888 rgbPlane.pac_data = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(frameSize, M4VS, (M4OSA_Char*)"Image clip RGB888 data"); 2889 if(rgbPlane.pac_data == M4OSA_NULL) 2890 { 2891 ALOGE("Failed to allocate memory for Image clip"); 2892 free(pTmpData); 2893 return M4ERR_ALLOC; 2894 } 2895 2896 /** Remove the alpha channel */ 2897 for (M4OSA_UInt32 i=0, j = 0; i < frameSize_argb; i++) { 2898 if ((i % 4) == 0) continue; 2899 rgbPlane.pac_data[j] = pTmpData[i]; 2900 j++; 2901 } 2902 free(pTmpData); 2903 2904 #ifdef FILE_DUMP 2905 FILE *fp = fopen("/sdcard/Input/test_rgb.raw", "wb"); 2906 if(fp == NULL) 2907 ALOGE("Errors file can not be created"); 2908 else { 2909 fwrite(rgbPlane.pac_data, frameSize, 1, fp); 2910 fclose(fp); 2911 } 2912 #endif 2913 rgbPlane.u_height = height; 2914 rgbPlane.u_width = width; 2915 rgbPlane.u_stride = width*3; 2916 rgbPlane.u_topleft = 0; 2917 2918 yuvPlane = (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc(3*sizeof(M4VIFI_ImagePlane), 2919 M4VS, (M4OSA_Char*)"M4xVSS_internalConvertRGBtoYUV: Output plane YUV"); 2920 yuvPlane[0].u_height = height; 2921 yuvPlane[0].u_width = width; 2922 yuvPlane[0].u_stride = width; 2923 yuvPlane[0].u_topleft = 0; 2924 yuvPlane[0].pac_data = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(yuvPlane[0].u_height * yuvPlane[0].u_width * 1.5, M4VS, (M4OSA_Char*)"imageClip YUV data"); 2925 2926 yuvPlane[1].u_height = yuvPlane[0].u_height >>1; 2927 yuvPlane[1].u_width = yuvPlane[0].u_width >> 1; 2928 yuvPlane[1].u_stride = yuvPlane[1].u_width; 2929 yuvPlane[1].u_topleft = 0; 2930 yuvPlane[1].pac_data = (M4VIFI_UInt8*)(yuvPlane[0].pac_data + yuvPlane[0].u_height * yuvPlane[0].u_width); 2931 2932 yuvPlane[2].u_height = yuvPlane[0].u_height >>1; 2933 yuvPlane[2].u_width = yuvPlane[0].u_width >> 1; 2934 yuvPlane[2].u_stride = yuvPlane[2].u_width; 2935 yuvPlane[2].u_topleft = 0; 2936 yuvPlane[2].pac_data = (M4VIFI_UInt8*)(yuvPlane[1].pac_data + yuvPlane[1].u_height * yuvPlane[1].u_width); 2937 2938 2939 err = M4VIFI_RGB888toYUV420(M4OSA_NULL, &rgbPlane, yuvPlane); 2940 //err = M4VIFI_BGR888toYUV420(M4OSA_NULL, &rgbPlane, yuvPlane); 2941 if(err != M4NO_ERROR) 2942 { 2943 ALOGE("error when converting from RGB to YUV: 0x%x\n", (unsigned int)err); 2944 } 2945 free(rgbPlane.pac_data); 2946 2947 //ALOGE("RGB to YUV done"); 2948 #ifdef FILE_DUMP 2949 FILE *fp1 = fopen("/sdcard/Input/test_yuv.raw", "wb"); 2950 if(fp1 == NULL) 2951 ALOGE("Errors file can not be created"); 2952 else { 2953 fwrite(yuvPlane[0].pac_data, yuvPlane[0].u_height * yuvPlane[0].u_width * 1.5, 1, fp1); 2954 fclose(fp1); 2955 } 2956 #endif 2957 *pBuffer = yuvPlane[0].pac_data; 2958 free(yuvPlane); 2959 return M4NO_ERROR; 2960 2961 } 2962 M4OSA_Void prepareYUV420ImagePlane(M4VIFI_ImagePlane *plane, 2963 M4OSA_UInt32 width, M4OSA_UInt32 height, M4VIFI_UInt8 *buffer, 2964 M4OSA_UInt32 reportedWidth, M4OSA_UInt32 reportedHeight) { 2965 2966 //Y plane 2967 plane[0].u_width = width; 2968 plane[0].u_height = height; 2969 plane[0].u_stride = reportedWidth; 2970 plane[0].u_topleft = 0; 2971 plane[0].pac_data = buffer; 2972 2973 // U plane 2974 plane[1].u_width = width/2; 2975 plane[1].u_height = height/2; 2976 plane[1].u_stride = reportedWidth >> 1; 2977 plane[1].u_topleft = 0; 2978 plane[1].pac_data = buffer+(reportedWidth*reportedHeight); 2979 2980 // V Plane 2981 plane[2].u_width = width/2; 2982 plane[2].u_height = height/2; 2983 plane[2].u_stride = reportedWidth >> 1; 2984 plane[2].u_topleft = 0; 2985 plane[2].pac_data = plane[1].pac_data + ((reportedWidth/2)*(reportedHeight/2)); 2986 } 2987 2988 M4OSA_Void prepareYV12ImagePlane(M4VIFI_ImagePlane *plane, 2989 M4OSA_UInt32 width, M4OSA_UInt32 height, M4OSA_UInt32 stride, 2990 M4VIFI_UInt8 *buffer) { 2991 2992 //Y plane 2993 plane[0].u_width = width; 2994 plane[0].u_height = height; 2995 plane[0].u_stride = stride; 2996 plane[0].u_topleft = 0; 2997 plane[0].pac_data = buffer; 2998 2999 // U plane 3000 plane[1].u_width = width/2; 3001 plane[1].u_height = height/2; 3002 plane[1].u_stride = android::PreviewRenderer::ALIGN(plane[0].u_stride/2, 16); 3003 plane[1].u_topleft = 0; 3004 plane[1].pac_data = (buffer 3005 + plane[0].u_height * plane[0].u_stride 3006 + (plane[0].u_height/2) * android::PreviewRenderer::ALIGN(( 3007 plane[0].u_stride / 2), 16)); 3008 3009 // V Plane 3010 plane[2].u_width = width/2; 3011 plane[2].u_height = height/2; 3012 plane[2].u_stride = android::PreviewRenderer::ALIGN(plane[0].u_stride/2, 16); 3013 plane[2].u_topleft = 0; 3014 plane[2].pac_data = (buffer + 3015 plane[0].u_height * android::PreviewRenderer::ALIGN(plane[0].u_stride, 16)); 3016 3017 3018 } 3019 3020 M4OSA_Void swapImagePlanes( 3021 M4VIFI_ImagePlane *planeIn, M4VIFI_ImagePlane *planeOut, 3022 M4VIFI_UInt8 *buffer1, M4VIFI_UInt8 *buffer2) { 3023 3024 planeIn[0].u_height = planeOut[0].u_height; 3025 planeIn[0].u_width = planeOut[0].u_width; 3026 planeIn[0].u_stride = planeOut[0].u_stride; 3027 planeIn[0].u_topleft = planeOut[0].u_topleft; 3028 planeIn[0].pac_data = planeOut[0].pac_data; 3029 3030 /** 3031 * U plane */ 3032 planeIn[1].u_width = planeOut[1].u_width; 3033 planeIn[1].u_height = planeOut[1].u_height; 3034 planeIn[1].u_stride = planeOut[1].u_stride; 3035 planeIn[1].u_topleft = planeOut[1].u_topleft; 3036 planeIn[1].pac_data = planeOut[1].pac_data; 3037 /** 3038 * V Plane */ 3039 planeIn[2].u_width = planeOut[2].u_width; 3040 planeIn[2].u_height = planeOut[2].u_height; 3041 planeIn[2].u_stride = planeOut[2].u_stride; 3042 planeIn[2].u_topleft = planeOut[2].u_topleft; 3043 planeIn[2].pac_data = planeOut[2].pac_data; 3044 3045 if(planeOut[0].pac_data == (M4VIFI_UInt8*)buffer1) 3046 { 3047 planeOut[0].pac_data = (M4VIFI_UInt8*)buffer2; 3048 planeOut[1].pac_data = (M4VIFI_UInt8*)(buffer2 + 3049 planeOut[0].u_width*planeOut[0].u_height); 3050 3051 planeOut[2].pac_data = (M4VIFI_UInt8*)(buffer2 + 3052 planeOut[0].u_width*planeOut[0].u_height + 3053 planeOut[1].u_width*planeOut[1].u_height); 3054 } 3055 else 3056 { 3057 planeOut[0].pac_data = (M4VIFI_UInt8*)buffer1; 3058 planeOut[1].pac_data = (M4VIFI_UInt8*)(buffer1 + 3059 planeOut[0].u_width*planeOut[0].u_height); 3060 3061 planeOut[2].pac_data = (M4VIFI_UInt8*)(buffer1 + 3062 planeOut[0].u_width*planeOut[0].u_height + 3063 planeOut[1].u_width*planeOut[1].u_height); 3064 } 3065 3066 } 3067 3068 M4OSA_Void computePercentageDone( 3069 M4OSA_UInt32 ctsMs, M4OSA_UInt32 effectStartTimeMs, 3070 M4OSA_UInt32 effectDuration, M4OSA_Double *percentageDone) { 3071 3072 M4OSA_Double videoEffectTime =0; 3073 3074 // Compute how far from the beginning of the effect we are, in clip-base time. 3075 videoEffectTime = 3076 (M4OSA_Int32)(ctsMs+ 0.5) - effectStartTimeMs; 3077 3078 // To calculate %, substract timeIncrement 3079 // because effect should finish on the last frame 3080 // which is from CTS = (eof-timeIncrement) till CTS = eof 3081 *percentageDone = 3082 videoEffectTime / ((M4OSA_Float)effectDuration); 3083 3084 if(*percentageDone < 0.0) *percentageDone = 0.0; 3085 if(*percentageDone > 1.0) *percentageDone = 1.0; 3086 3087 } 3088 3089 3090 M4OSA_Void computeProgressForVideoEffect( 3091 M4OSA_UInt32 ctsMs, M4OSA_UInt32 effectStartTimeMs, 3092 M4OSA_UInt32 effectDuration, M4VSS3GPP_ExternalProgress* extProgress) { 3093 3094 M4OSA_Double percentageDone =0; 3095 3096 computePercentageDone(ctsMs, effectStartTimeMs, effectDuration, &percentageDone); 3097 3098 extProgress->uiProgress = (M4OSA_UInt32)( percentageDone * 1000 ); 3099 extProgress->uiOutputTime = (M4OSA_UInt32)(ctsMs + 0.5); 3100 extProgress->uiClipTime = extProgress->uiOutputTime; 3101 extProgress->bIsLast = M4OSA_FALSE; 3102 } 3103 3104 M4OSA_ERR prepareFramingStructure( 3105 M4xVSS_FramingStruct* framingCtx, 3106 M4VSS3GPP_EffectSettings* effectsSettings, M4OSA_UInt32 index, 3107 M4VIFI_UInt8* overlayRGB, M4VIFI_UInt8* overlayYUV) { 3108 3109 M4OSA_ERR err = M4NO_ERROR; 3110 3111 // Force input RGB buffer to even size to avoid errors in YUV conversion 3112 framingCtx->FramingRgb = effectsSettings[index].xVSS.pFramingBuffer; 3113 framingCtx->FramingRgb->u_width = framingCtx->FramingRgb->u_width & ~1; 3114 framingCtx->FramingRgb->u_height = framingCtx->FramingRgb->u_height & ~1; 3115 framingCtx->FramingYuv = NULL; 3116 3117 framingCtx->duration = effectsSettings[index].uiDuration; 3118 framingCtx->topleft_x = effectsSettings[index].xVSS.topleft_x; 3119 framingCtx->topleft_y = effectsSettings[index].xVSS.topleft_y; 3120 framingCtx->pCurrent = framingCtx; 3121 framingCtx->pNext = framingCtx; 3122 framingCtx->previousClipTime = -1; 3123 3124 framingCtx->alphaBlendingStruct = 3125 (M4xVSS_internalEffectsAlphaBlending*)M4OSA_32bitAlignedMalloc( 3126 sizeof(M4xVSS_internalEffectsAlphaBlending), M4VS, 3127 (M4OSA_Char*)"alpha blending struct"); 3128 3129 framingCtx->alphaBlendingStruct->m_fadeInTime = 3130 effectsSettings[index].xVSS.uialphaBlendingFadeInTime; 3131 3132 framingCtx->alphaBlendingStruct->m_fadeOutTime = 3133 effectsSettings[index].xVSS.uialphaBlendingFadeOutTime; 3134 3135 framingCtx->alphaBlendingStruct->m_end = 3136 effectsSettings[index].xVSS.uialphaBlendingEnd; 3137 3138 framingCtx->alphaBlendingStruct->m_middle = 3139 effectsSettings[index].xVSS.uialphaBlendingMiddle; 3140 3141 framingCtx->alphaBlendingStruct->m_start = 3142 effectsSettings[index].xVSS.uialphaBlendingStart; 3143 3144 // If new Overlay buffer, convert from RGB to YUV 3145 if((overlayRGB != framingCtx->FramingRgb->pac_data) || (overlayYUV == NULL) ) { 3146 3147 // If YUV buffer exists, delete it 3148 if(overlayYUV != NULL) { 3149 free(overlayYUV); 3150 overlayYUV = NULL; 3151 } 3152 if(effectsSettings[index].xVSS.rgbType == M4VSS3GPP_kRGB565) { 3153 // Input RGB565 plane is provided, 3154 // let's convert it to YUV420, and update framing structure 3155 err = M4xVSS_internalConvertRGBtoYUV(framingCtx); 3156 } 3157 else if(effectsSettings[index].xVSS.rgbType == M4VSS3GPP_kRGB888) { 3158 // Input RGB888 plane is provided, 3159 // let's convert it to YUV420, and update framing structure 3160 err = M4xVSS_internalConvertRGB888toYUV(framingCtx); 3161 } 3162 else { 3163 err = M4ERR_PARAMETER; 3164 } 3165 overlayYUV = framingCtx->FramingYuv[0].pac_data; 3166 overlayRGB = framingCtx->FramingRgb->pac_data; 3167 3168 } 3169 else { 3170 ALOGV(" YUV buffer reuse"); 3171 framingCtx->FramingYuv = (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc( 3172 3*sizeof(M4VIFI_ImagePlane), M4VS, (M4OSA_Char*)"YUV"); 3173 3174 if(framingCtx->FramingYuv == M4OSA_NULL) { 3175 return M4ERR_ALLOC; 3176 } 3177 3178 framingCtx->FramingYuv[0].u_width = framingCtx->FramingRgb->u_width; 3179 framingCtx->FramingYuv[0].u_height = framingCtx->FramingRgb->u_height; 3180 framingCtx->FramingYuv[0].u_topleft = 0; 3181 framingCtx->FramingYuv[0].u_stride = framingCtx->FramingRgb->u_width; 3182 framingCtx->FramingYuv[0].pac_data = (M4VIFI_UInt8*)overlayYUV; 3183 3184 framingCtx->FramingYuv[1].u_width = (framingCtx->FramingRgb->u_width)>>1; 3185 framingCtx->FramingYuv[1].u_height = (framingCtx->FramingRgb->u_height)>>1; 3186 framingCtx->FramingYuv[1].u_topleft = 0; 3187 framingCtx->FramingYuv[1].u_stride = (framingCtx->FramingRgb->u_width)>>1; 3188 framingCtx->FramingYuv[1].pac_data = framingCtx->FramingYuv[0].pac_data + 3189 framingCtx->FramingYuv[0].u_width * framingCtx->FramingYuv[0].u_height; 3190 3191 framingCtx->FramingYuv[2].u_width = (framingCtx->FramingRgb->u_width)>>1; 3192 framingCtx->FramingYuv[2].u_height = (framingCtx->FramingRgb->u_height)>>1; 3193 framingCtx->FramingYuv[2].u_topleft = 0; 3194 framingCtx->FramingYuv[2].u_stride = (framingCtx->FramingRgb->u_width)>>1; 3195 framingCtx->FramingYuv[2].pac_data = framingCtx->FramingYuv[1].pac_data + 3196 framingCtx->FramingYuv[1].u_width * framingCtx->FramingYuv[1].u_height; 3197 3198 framingCtx->duration = 0; 3199 framingCtx->previousClipTime = -1; 3200 framingCtx->previewOffsetClipTime = -1; 3201 3202 } 3203 return err; 3204 } 3205 3206 M4OSA_ERR applyColorEffect(M4xVSS_VideoEffectType colorEffect, 3207 M4VIFI_ImagePlane *planeIn, M4VIFI_ImagePlane *planeOut, 3208 M4VIFI_UInt8 *buffer1, M4VIFI_UInt8 *buffer2, M4OSA_UInt16 rgbColorData) { 3209 3210 M4xVSS_ColorStruct colorContext; 3211 M4OSA_ERR err = M4NO_ERROR; 3212 3213 colorContext.colorEffectType = colorEffect; 3214 colorContext.rgb16ColorData = rgbColorData; 3215 3216 err = M4VSS3GPP_externalVideoEffectColor( 3217 (M4OSA_Void *)&colorContext, planeIn, planeOut, NULL, 3218 colorEffect); 3219 3220 if(err != M4NO_ERROR) { 3221 ALOGV("M4VSS3GPP_externalVideoEffectColor(%d) error %d", 3222 colorEffect, err); 3223 3224 if(NULL != buffer1) { 3225 free(buffer1); 3226 buffer1 = NULL; 3227 } 3228 if(NULL != buffer2) { 3229 free(buffer2); 3230 buffer2 = NULL; 3231 } 3232 return err; 3233 } 3234 3235 // The out plane now becomes the in plane for adding other effects 3236 swapImagePlanes(planeIn, planeOut, buffer1, buffer2); 3237 3238 return err; 3239 } 3240 3241 M4OSA_ERR applyLumaEffect(M4VSS3GPP_VideoEffectType videoEffect, 3242 M4VIFI_ImagePlane *planeIn, M4VIFI_ImagePlane *planeOut, 3243 M4VIFI_UInt8 *buffer1, M4VIFI_UInt8 *buffer2, M4OSA_Int32 lum_factor) { 3244 3245 M4OSA_ERR err = M4NO_ERROR; 3246 3247 err = M4VFL_modifyLumaWithScale( 3248 (M4ViComImagePlane*)planeIn,(M4ViComImagePlane*)planeOut, 3249 lum_factor, NULL); 3250 3251 if(err != M4NO_ERROR) { 3252 ALOGE("M4VFL_modifyLumaWithScale(%d) error %d", videoEffect, (int)err); 3253 3254 if(NULL != buffer1) { 3255 free(buffer1); 3256 buffer1= NULL; 3257 } 3258 if(NULL != buffer2) { 3259 free(buffer2); 3260 buffer2= NULL; 3261 } 3262 return err; 3263 } 3264 3265 // The out plane now becomes the in plane for adding other effects 3266 swapImagePlanes(planeIn, planeOut,(M4VIFI_UInt8 *)buffer1, 3267 (M4VIFI_UInt8 *)buffer2); 3268 3269 return err; 3270 } 3271 3272 M4OSA_ERR applyEffectsAndRenderingMode(vePostProcessParams *params, 3273 M4OSA_UInt32 reportedWidth, M4OSA_UInt32 reportedHeight) { 3274 3275 M4OSA_ERR err = M4NO_ERROR; 3276 M4VIFI_ImagePlane planeIn[3], planeOut[3]; 3277 M4VIFI_UInt8 *finalOutputBuffer = NULL, *tempOutputBuffer= NULL; 3278 M4OSA_Double percentageDone =0; 3279 M4OSA_Int32 lum_factor; 3280 M4VSS3GPP_ExternalProgress extProgress; 3281 M4xVSS_FiftiesStruct fiftiesCtx; 3282 M4OSA_UInt32 frameSize = 0, i=0; 3283 3284 frameSize = (params->videoWidth*params->videoHeight*3) >> 1; 3285 3286 finalOutputBuffer = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(frameSize, M4VS, 3287 (M4OSA_Char*)("lvpp finalOutputBuffer")); 3288 3289 if(finalOutputBuffer == NULL) { 3290 ALOGE("applyEffectsAndRenderingMode: malloc error"); 3291 return M4ERR_ALLOC; 3292 } 3293 3294 // allocate the tempOutputBuffer 3295 tempOutputBuffer = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc( 3296 ((params->videoHeight*params->videoWidth*3)>>1), M4VS, (M4OSA_Char*)("lvpp colorBuffer")); 3297 3298 if(tempOutputBuffer == NULL) { 3299 ALOGE("applyEffectsAndRenderingMode: malloc error tempOutputBuffer"); 3300 if(NULL != finalOutputBuffer) { 3301 free(finalOutputBuffer); 3302 finalOutputBuffer = NULL; 3303 } 3304 return M4ERR_ALLOC; 3305 } 3306 3307 // Initialize the In plane 3308 prepareYUV420ImagePlane(planeIn, params->videoWidth, params->videoHeight, 3309 params->vidBuffer, reportedWidth, reportedHeight); 3310 3311 // Initialize the Out plane 3312 prepareYUV420ImagePlane(planeOut, params->videoWidth, params->videoHeight, 3313 (M4VIFI_UInt8 *)tempOutputBuffer, params->videoWidth, params->videoHeight); 3314 3315 // The planeIn contains the YUV420 input data to postprocessing node 3316 // and planeOut will contain the YUV420 data with effect 3317 // In each successive if condition, apply filter to successive 3318 // output YUV frame so that concurrent effects are both applied 3319 3320 if(params->currentVideoEffect & VIDEO_EFFECT_BLACKANDWHITE) { 3321 err = applyColorEffect(M4xVSS_kVideoEffectType_BlackAndWhite, 3322 planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, 3323 (M4VIFI_UInt8 *)tempOutputBuffer, 0); 3324 if(err != M4NO_ERROR) { 3325 return err; 3326 } 3327 } 3328 3329 if(params->currentVideoEffect & VIDEO_EFFECT_PINK) { 3330 err = applyColorEffect(M4xVSS_kVideoEffectType_Pink, 3331 planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, 3332 (M4VIFI_UInt8 *)tempOutputBuffer, 0); 3333 if(err != M4NO_ERROR) { 3334 return err; 3335 } 3336 } 3337 3338 if(params->currentVideoEffect & VIDEO_EFFECT_GREEN) { 3339 err = applyColorEffect(M4xVSS_kVideoEffectType_Green, 3340 planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, 3341 (M4VIFI_UInt8 *)tempOutputBuffer, 0); 3342 if(err != M4NO_ERROR) { 3343 return err; 3344 } 3345 } 3346 3347 if(params->currentVideoEffect & VIDEO_EFFECT_SEPIA) { 3348 err = applyColorEffect(M4xVSS_kVideoEffectType_Sepia, 3349 planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, 3350 (M4VIFI_UInt8 *)tempOutputBuffer, 0); 3351 if(err != M4NO_ERROR) { 3352 return err; 3353 } 3354 } 3355 3356 if(params->currentVideoEffect & VIDEO_EFFECT_NEGATIVE) { 3357 err = applyColorEffect(M4xVSS_kVideoEffectType_Negative, 3358 planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, 3359 (M4VIFI_UInt8 *)tempOutputBuffer, 0); 3360 if(err != M4NO_ERROR) { 3361 return err; 3362 } 3363 } 3364 3365 if(params->currentVideoEffect & VIDEO_EFFECT_GRADIENT) { 3366 // find the effect in effectSettings array 3367 for(i=0;i<params->numberEffects;i++) { 3368 if(params->effectsSettings[i].VideoEffectType == 3369 (M4VSS3GPP_VideoEffectType)M4xVSS_kVideoEffectType_Gradient) 3370 break; 3371 } 3372 err = applyColorEffect(M4xVSS_kVideoEffectType_Gradient, 3373 planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, 3374 (M4VIFI_UInt8 *)tempOutputBuffer, 3375 params->effectsSettings[i].xVSS.uiRgb16InputColor); 3376 if(err != M4NO_ERROR) { 3377 return err; 3378 } 3379 } 3380 3381 if(params->currentVideoEffect & VIDEO_EFFECT_COLOR_RGB16) { 3382 // Find the effect in effectSettings array 3383 for(i=0;i<params->numberEffects;i++) { 3384 if(params->effectsSettings[i].VideoEffectType == 3385 (M4VSS3GPP_VideoEffectType)M4xVSS_kVideoEffectType_ColorRGB16) 3386 break; 3387 } 3388 err = applyColorEffect(M4xVSS_kVideoEffectType_ColorRGB16, 3389 planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, 3390 (M4VIFI_UInt8 *)tempOutputBuffer, 3391 params->effectsSettings[i].xVSS.uiRgb16InputColor); 3392 if(err != M4NO_ERROR) { 3393 return err; 3394 } 3395 } 3396 3397 if(params->currentVideoEffect & VIDEO_EFFECT_FIFTIES) { 3398 // Find the effect in effectSettings array 3399 for(i=0;i<params->numberEffects;i++) { 3400 if(params->effectsSettings[i].VideoEffectType == 3401 (M4VSS3GPP_VideoEffectType)M4xVSS_kVideoEffectType_Fifties) 3402 break; 3403 } 3404 if(i < params->numberEffects) { 3405 computeProgressForVideoEffect(params->timeMs, 3406 params->effectsSettings[i].uiStartTime, 3407 params->effectsSettings[i].uiDuration, &extProgress); 3408 3409 if(params->isFiftiesEffectStarted) { 3410 fiftiesCtx.previousClipTime = -1; 3411 } 3412 fiftiesCtx.fiftiesEffectDuration = 3413 1000/params->effectsSettings[i].xVSS.uiFiftiesOutFrameRate; 3414 3415 fiftiesCtx.shiftRandomValue = 0; 3416 fiftiesCtx.stripeRandomValue = 0; 3417 3418 err = M4VSS3GPP_externalVideoEffectFifties( 3419 (M4OSA_Void *)&fiftiesCtx, planeIn, planeOut, &extProgress, 3420 M4xVSS_kVideoEffectType_Fifties); 3421 3422 if(err != M4NO_ERROR) { 3423 ALOGE("M4VSS3GPP_externalVideoEffectFifties error 0x%x", (unsigned int)err); 3424 3425 if(NULL != finalOutputBuffer) { 3426 free(finalOutputBuffer); 3427 finalOutputBuffer = NULL; 3428 } 3429 if(NULL != tempOutputBuffer) { 3430 free(tempOutputBuffer); 3431 tempOutputBuffer = NULL; 3432 } 3433 return err; 3434 } 3435 3436 // The out plane now becomes the in plane for adding other effects 3437 swapImagePlanes(planeIn, planeOut,(M4VIFI_UInt8 *)finalOutputBuffer, 3438 (M4VIFI_UInt8 *)tempOutputBuffer); 3439 } 3440 } 3441 3442 if(params->currentVideoEffect & VIDEO_EFFECT_FRAMING) { 3443 3444 M4xVSS_FramingStruct framingCtx; 3445 // Find the effect in effectSettings array 3446 for(i=0;i<params->numberEffects;i++) { 3447 if(params->effectsSettings[i].VideoEffectType == 3448 (M4VSS3GPP_VideoEffectType)M4xVSS_kVideoEffectType_Framing) { 3449 if((params->effectsSettings[i].uiStartTime <= params->timeMs + params->timeOffset) && 3450 ((params->effectsSettings[i].uiStartTime+ 3451 params->effectsSettings[i].uiDuration) >= params->timeMs + params->timeOffset)) 3452 { 3453 break; 3454 } 3455 } 3456 } 3457 if(i < params->numberEffects) { 3458 computeProgressForVideoEffect(params->timeMs, 3459 params->effectsSettings[i].uiStartTime, 3460 params->effectsSettings[i].uiDuration, &extProgress); 3461 3462 err = prepareFramingStructure(&framingCtx, 3463 params->effectsSettings, i, params->overlayFrameRGBBuffer, 3464 params->overlayFrameYUVBuffer); 3465 3466 if(err == M4NO_ERROR) { 3467 err = M4VSS3GPP_externalVideoEffectFraming( 3468 (M4OSA_Void *)&framingCtx, planeIn, planeOut, &extProgress, 3469 M4xVSS_kVideoEffectType_Framing); 3470 } 3471 3472 free(framingCtx.alphaBlendingStruct); 3473 3474 if(framingCtx.FramingYuv != NULL) { 3475 free(framingCtx.FramingYuv); 3476 framingCtx.FramingYuv = NULL; 3477 } 3478 //If prepareFramingStructure / M4VSS3GPP_externalVideoEffectFraming 3479 // returned error, then return from function 3480 if(err != M4NO_ERROR) { 3481 3482 if(NULL != finalOutputBuffer) { 3483 free(finalOutputBuffer); 3484 finalOutputBuffer = NULL; 3485 } 3486 if(NULL != tempOutputBuffer) { 3487 free(tempOutputBuffer); 3488 tempOutputBuffer = NULL; 3489 } 3490 return err; 3491 } 3492 3493 // The out plane now becomes the in plane for adding other effects 3494 swapImagePlanes(planeIn, planeOut,(M4VIFI_UInt8 *)finalOutputBuffer, 3495 (M4VIFI_UInt8 *)tempOutputBuffer); 3496 } 3497 } 3498 3499 if(params->currentVideoEffect & VIDEO_EFFECT_FADEFROMBLACK) { 3500 /* find the effect in effectSettings array*/ 3501 for(i=0;i<params->numberEffects;i++) { 3502 if(params->effectsSettings[i].VideoEffectType == 3503 M4VSS3GPP_kVideoEffectType_FadeFromBlack) 3504 break; 3505 } 3506 3507 if(i < params->numberEffects) { 3508 computePercentageDone(params->timeMs, 3509 params->effectsSettings[i].uiStartTime, 3510 params->effectsSettings[i].uiDuration, &percentageDone); 3511 3512 // Compute where we are in the effect (scale is 0->1024) 3513 lum_factor = (M4OSA_Int32)( percentageDone * 1024 ); 3514 // Apply the darkening effect 3515 err = applyLumaEffect(M4VSS3GPP_kVideoEffectType_FadeFromBlack, 3516 planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, 3517 (M4VIFI_UInt8 *)tempOutputBuffer, lum_factor); 3518 if(err != M4NO_ERROR) { 3519 return err; 3520 } 3521 } 3522 } 3523 3524 if(params->currentVideoEffect & VIDEO_EFFECT_FADETOBLACK) { 3525 // Find the effect in effectSettings array 3526 for(i=0;i<params->numberEffects;i++) { 3527 if(params->effectsSettings[i].VideoEffectType == 3528 M4VSS3GPP_kVideoEffectType_FadeToBlack) 3529 break; 3530 } 3531 if(i < params->numberEffects) { 3532 computePercentageDone(params->timeMs, 3533 params->effectsSettings[i].uiStartTime, 3534 params->effectsSettings[i].uiDuration, &percentageDone); 3535 3536 // Compute where we are in the effect (scale is 0->1024) 3537 lum_factor = (M4OSA_Int32)( (1.0-percentageDone) * 1024 ); 3538 // Apply the darkening effect 3539 err = applyLumaEffect(M4VSS3GPP_kVideoEffectType_FadeToBlack, 3540 planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, 3541 (M4VIFI_UInt8 *)tempOutputBuffer, lum_factor); 3542 if(err != M4NO_ERROR) { 3543 return err; 3544 } 3545 } 3546 } 3547 3548 ALOGV("doMediaRendering CALL getBuffer()"); 3549 // Set the output YUV420 plane to be compatible with YV12 format 3550 // W & H even 3551 // YVU instead of YUV 3552 // align buffers on 32 bits 3553 3554 // Y plane 3555 //in YV12 format, sizes must be even 3556 M4OSA_UInt32 yv12PlaneWidth = ((params->outVideoWidth +1)>>1)<<1; 3557 M4OSA_UInt32 yv12PlaneHeight = ((params->outVideoHeight+1)>>1)<<1; 3558 3559 prepareYV12ImagePlane(planeOut, yv12PlaneWidth, yv12PlaneHeight, 3560 (M4OSA_UInt32)params->outBufferStride, (M4VIFI_UInt8 *)params->pOutBuffer); 3561 3562 err = applyRenderingMode(planeIn, planeOut, params->renderingMode); 3563 3564 if(M4OSA_NULL != finalOutputBuffer) { 3565 free(finalOutputBuffer); 3566 finalOutputBuffer= M4OSA_NULL; 3567 } 3568 if(M4OSA_NULL != tempOutputBuffer) { 3569 free(tempOutputBuffer); 3570 tempOutputBuffer = M4OSA_NULL; 3571 } 3572 if(err != M4NO_ERROR) { 3573 ALOGV("doVideoPostProcessing: applyRenderingMode returned err=%d",err); 3574 return err; 3575 } 3576 return M4NO_ERROR; 3577 } 3578 3579 android::status_t getVideoSizeByResolution( 3580 M4VIDEOEDITING_VideoFrameSize resolution, 3581 uint32_t *pWidth, uint32_t *pHeight) { 3582 3583 uint32_t frameWidth, frameHeight; 3584 3585 if (pWidth == NULL) { 3586 ALOGE("getVideoFrameSizeByResolution invalid pointer for pWidth"); 3587 return android::BAD_VALUE; 3588 } 3589 if (pHeight == NULL) { 3590 ALOGE("getVideoFrameSizeByResolution invalid pointer for pHeight"); 3591 return android::BAD_VALUE; 3592 } 3593 3594 switch (resolution) { 3595 case M4VIDEOEDITING_kSQCIF: 3596 frameWidth = 128; 3597 frameHeight = 96; 3598 break; 3599 3600 case M4VIDEOEDITING_kQQVGA: 3601 frameWidth = 160; 3602 frameHeight = 120; 3603 break; 3604 3605 case M4VIDEOEDITING_kQCIF: 3606 frameWidth = 176; 3607 frameHeight = 144; 3608 break; 3609 3610 case M4VIDEOEDITING_kQVGA: 3611 frameWidth = 320; 3612 frameHeight = 240; 3613 break; 3614 3615 case M4VIDEOEDITING_kCIF: 3616 frameWidth = 352; 3617 frameHeight = 288; 3618 break; 3619 3620 case M4VIDEOEDITING_kVGA: 3621 frameWidth = 640; 3622 frameHeight = 480; 3623 break; 3624 3625 case M4VIDEOEDITING_kWVGA: 3626 frameWidth = 800; 3627 frameHeight = 480; 3628 break; 3629 3630 case M4VIDEOEDITING_kNTSC: 3631 frameWidth = 720; 3632 frameHeight = 480; 3633 break; 3634 3635 case M4VIDEOEDITING_k640_360: 3636 frameWidth = 640; 3637 frameHeight = 360; 3638 break; 3639 3640 case M4VIDEOEDITING_k854_480: 3641 frameWidth = 854; 3642 frameHeight = 480; 3643 break; 3644 3645 case M4VIDEOEDITING_k1280_720: 3646 frameWidth = 1280; 3647 frameHeight = 720; 3648 break; 3649 3650 case M4VIDEOEDITING_k1080_720: 3651 frameWidth = 1080; 3652 frameHeight = 720; 3653 break; 3654 3655 case M4VIDEOEDITING_k960_720: 3656 frameWidth = 960; 3657 frameHeight = 720; 3658 break; 3659 3660 case M4VIDEOEDITING_k1920_1080: 3661 frameWidth = 1920; 3662 frameHeight = 1080; 3663 break; 3664 3665 default: 3666 ALOGE("Unsupported video resolution %d.", resolution); 3667 return android::BAD_VALUE; 3668 } 3669 3670 *pWidth = frameWidth; 3671 *pHeight = frameHeight; 3672 3673 return android::OK; 3674 } 3675 3676 M4VIFI_UInt8 M4VIFI_Rotate90LeftYUV420toYUV420(void* pUserData, 3677 M4VIFI_ImagePlane *pPlaneIn, M4VIFI_ImagePlane *pPlaneOut) { 3678 3679 M4VIFI_Int32 plane_number; 3680 M4VIFI_UInt32 i,j, u_stride; 3681 M4VIFI_UInt8 *p_buf_src, *p_buf_dest; 3682 3683 /**< Loop on Y,U and V planes */ 3684 for (plane_number = 0; plane_number < 3; plane_number++) { 3685 /**< Get adresses of first valid pixel in input and output buffer */ 3686 /**< As we have a -90 rotation, first needed pixel is the upper-right one */ 3687 p_buf_src = 3688 &(pPlaneIn[plane_number].pac_data[pPlaneIn[plane_number].u_topleft]) + 3689 pPlaneOut[plane_number].u_height - 1 ; 3690 p_buf_dest = 3691 &(pPlaneOut[plane_number].pac_data[pPlaneOut[plane_number].u_topleft]); 3692 u_stride = pPlaneIn[plane_number].u_stride; 3693 /**< Loop on output rows */ 3694 for (i = 0; i < pPlaneOut[plane_number].u_height; i++) { 3695 /**< Loop on all output pixels in a row */ 3696 for (j = 0; j < pPlaneOut[plane_number].u_width; j++) { 3697 *p_buf_dest++= *p_buf_src; 3698 p_buf_src += u_stride; /**< Go to the next row */ 3699 } 3700 3701 /**< Go on next row of the output frame */ 3702 p_buf_dest += 3703 pPlaneOut[plane_number].u_stride - pPlaneOut[plane_number].u_width; 3704 /**< Go to next pixel in the last row of the input frame*/ 3705 p_buf_src -= 3706 pPlaneIn[plane_number].u_stride * pPlaneOut[plane_number].u_width + 1 ; 3707 } 3708 } 3709 3710 return M4VIFI_OK; 3711 } 3712 3713 M4VIFI_UInt8 M4VIFI_Rotate90RightYUV420toYUV420(void* pUserData, 3714 M4VIFI_ImagePlane *pPlaneIn, M4VIFI_ImagePlane *pPlaneOut) { 3715 3716 M4VIFI_Int32 plane_number; 3717 M4VIFI_UInt32 i,j, u_stride; 3718 M4VIFI_UInt8 *p_buf_src, *p_buf_dest; 3719 3720 /**< Loop on Y,U and V planes */ 3721 for (plane_number = 0; plane_number < 3; plane_number++) { 3722 /**< Get adresses of first valid pixel in input and output buffer */ 3723 /**< As we have a +90 rotation, first needed pixel is the left-down one */ 3724 p_buf_src = 3725 &(pPlaneIn[plane_number].pac_data[pPlaneIn[plane_number].u_topleft]) + 3726 (pPlaneIn[plane_number].u_stride * (pPlaneOut[plane_number].u_width - 1)); 3727 p_buf_dest = 3728 &(pPlaneOut[plane_number].pac_data[pPlaneOut[plane_number].u_topleft]); 3729 u_stride = pPlaneIn[plane_number].u_stride; 3730 /**< Loop on output rows */ 3731 for (i = 0; i < pPlaneOut[plane_number].u_height; i++) { 3732 /**< Loop on all output pixels in a row */ 3733 for (j = 0; j < pPlaneOut[plane_number].u_width; j++) { 3734 *p_buf_dest++= *p_buf_src; 3735 p_buf_src -= u_stride; /**< Go to the previous row */ 3736 } 3737 3738 /**< Go on next row of the output frame */ 3739 p_buf_dest += 3740 pPlaneOut[plane_number].u_stride - pPlaneOut[plane_number].u_width; 3741 /**< Go to next pixel in the last row of the input frame*/ 3742 p_buf_src += 3743 pPlaneIn[plane_number].u_stride * pPlaneOut[plane_number].u_width +1 ; 3744 } 3745 } 3746 3747 return M4VIFI_OK; 3748 } 3749 3750 M4VIFI_UInt8 M4VIFI_Rotate180YUV420toYUV420(void* pUserData, 3751 M4VIFI_ImagePlane *pPlaneIn, M4VIFI_ImagePlane *pPlaneOut) { 3752 M4VIFI_Int32 plane_number; 3753 M4VIFI_UInt32 i,j; 3754 M4VIFI_UInt8 *p_buf_src, *p_buf_dest, temp_pix1; 3755 3756 /**< Loop on Y,U and V planes */ 3757 for (plane_number = 0; plane_number < 3; plane_number++) { 3758 /**< Get adresses of first valid pixel in input and output buffer */ 3759 p_buf_src = 3760 &(pPlaneIn[plane_number].pac_data[pPlaneIn[plane_number].u_topleft]); 3761 p_buf_dest = 3762 &(pPlaneOut[plane_number].pac_data[pPlaneOut[plane_number].u_topleft]); 3763 3764 /**< If pPlaneIn = pPlaneOut, the algorithm will be different */ 3765 if (p_buf_src == p_buf_dest) { 3766 /**< Get Address of last pixel in the last row of the frame */ 3767 p_buf_dest += 3768 pPlaneOut[plane_number].u_stride*(pPlaneOut[plane_number].u_height-1) + 3769 pPlaneOut[plane_number].u_width - 1; 3770 3771 /**< We loop (height/2) times on the rows. 3772 * In case u_height is odd, the row at the middle of the frame 3773 * has to be processed as must be mirrored */ 3774 for (i = 0; i < ((pPlaneOut[plane_number].u_height)>>1); i++) { 3775 for (j = 0; j < pPlaneOut[plane_number].u_width; j++) { 3776 temp_pix1= *p_buf_dest; 3777 *p_buf_dest--= *p_buf_src; 3778 *p_buf_src++ = temp_pix1; 3779 } 3780 /**< Go on next row in top of frame */ 3781 p_buf_src += 3782 pPlaneOut[plane_number].u_stride - pPlaneOut[plane_number].u_width; 3783 /**< Go to the last pixel in previous row in bottom of frame*/ 3784 p_buf_dest -= 3785 pPlaneOut[plane_number].u_stride - pPlaneOut[plane_number].u_width; 3786 } 3787 3788 /**< Mirror middle row in case height is odd */ 3789 if ((pPlaneOut[plane_number].u_height%2)!= 0) { 3790 p_buf_src = 3791 &(pPlaneOut[plane_number].pac_data[pPlaneIn[plane_number].u_topleft]); 3792 p_buf_src += 3793 pPlaneOut[plane_number].u_stride*(pPlaneOut[plane_number].u_height>>1); 3794 p_buf_dest = 3795 p_buf_src + pPlaneOut[plane_number].u_width; 3796 3797 /**< We loop u_width/2 times on this row. 3798 * In case u_width is odd, the pixel at the middle of this row 3799 * remains unchanged */ 3800 for (j = 0; j < (pPlaneOut[plane_number].u_width>>1); j++) { 3801 temp_pix1= *p_buf_dest; 3802 *p_buf_dest--= *p_buf_src; 3803 *p_buf_src++ = temp_pix1; 3804 } 3805 } 3806 } else { 3807 /**< Get Address of last pixel in the last row of the output frame */ 3808 p_buf_dest += 3809 pPlaneOut[plane_number].u_stride*(pPlaneOut[plane_number].u_height-1) + 3810 pPlaneIn[plane_number].u_width - 1; 3811 3812 /**< Loop on rows */ 3813 for (i = 0; i < pPlaneOut[plane_number].u_height; i++) { 3814 for (j = 0; j < pPlaneOut[plane_number].u_width; j++) { 3815 *p_buf_dest--= *p_buf_src++; 3816 } 3817 3818 /**< Go on next row in top of input frame */ 3819 p_buf_src += 3820 pPlaneIn[plane_number].u_stride - pPlaneOut[plane_number].u_width; 3821 /**< Go to last pixel of previous row in bottom of input frame*/ 3822 p_buf_dest -= 3823 pPlaneOut[plane_number].u_stride - pPlaneOut[plane_number].u_width; 3824 } 3825 } 3826 } 3827 3828 return M4VIFI_OK; 3829 } 3830 3831 M4OSA_ERR applyVideoRotation(M4OSA_Void* pBuffer, M4OSA_UInt32 width, 3832 M4OSA_UInt32 height, M4OSA_UInt32 rotation) { 3833 3834 M4OSA_ERR err = M4NO_ERROR; 3835 M4VIFI_ImagePlane planeIn[3], planeOut[3]; 3836 3837 if (pBuffer == M4OSA_NULL) { 3838 ALOGE("applyVideoRotation: NULL input frame"); 3839 return M4ERR_PARAMETER; 3840 } 3841 M4OSA_UInt8* outPtr = (M4OSA_UInt8 *)M4OSA_32bitAlignedMalloc( 3842 (width*height*1.5), M4VS, (M4OSA_Char*)("rotation out ptr")); 3843 if (outPtr == M4OSA_NULL) { 3844 return M4ERR_ALLOC; 3845 } 3846 3847 // In plane 3848 prepareYUV420ImagePlane(planeIn, width, 3849 height, (M4VIFI_UInt8 *)pBuffer, width, height); 3850 3851 // Out plane 3852 if (rotation != 180) { 3853 prepareYUV420ImagePlane(planeOut, height, 3854 width, outPtr, height, width); 3855 } 3856 3857 switch(rotation) { 3858 case 90: 3859 M4VIFI_Rotate90RightYUV420toYUV420(M4OSA_NULL, planeIn, planeOut); 3860 memcpy(pBuffer, (void *)outPtr, (width*height*1.5)); 3861 break; 3862 3863 case 180: 3864 // In plane rotation, so planeOut = planeIn 3865 M4VIFI_Rotate180YUV420toYUV420(M4OSA_NULL, planeIn, planeIn); 3866 break; 3867 3868 case 270: 3869 M4VIFI_Rotate90LeftYUV420toYUV420(M4OSA_NULL, planeIn, planeOut); 3870 memcpy(pBuffer, (void *)outPtr, (width*height*1.5)); 3871 break; 3872 3873 default: 3874 ALOGE("invalid rotation param %d", (int)rotation); 3875 err = M4ERR_PARAMETER; 3876 break; 3877 } 3878 3879 free((void *)outPtr); 3880 return err; 3881 3882 } 3883 3884
