/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "VideoEditorTools.h" #include "PreviewRenderer.h" /*+ Handle the image files here */ #include /*- Handle the image files here */ const M4VIFI_UInt8 M4VIFI_ClipTable[1256] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; /* Division table for ( 65535/x ); x = 0 to 512 */ const M4VIFI_UInt16 M4VIFI_DivTable[512] = { 0, 65535, 32768, 21845, 16384, 13107, 10922, 9362, 8192, 7281, 6553, 5957, 5461, 5041, 4681, 4369, 4096, 3855, 3640, 3449, 3276, 3120, 2978, 2849, 2730, 2621, 2520, 2427, 2340, 2259, 2184, 2114, 2048, 1985, 1927, 1872, 1820, 1771, 1724, 1680, 1638, 1598, 1560, 1524, 1489, 1456, 1424, 1394, 1365, 1337, 1310, 1285, 1260, 1236, 1213, 1191, 1170, 1149, 1129, 1110, 1092, 1074, 1057, 1040, 1024, 1008, 992, 978, 963, 949, 936, 923, 910, 897, 885, 873, 862, 851, 840, 829, 819, 809, 799, 789, 780, 771, 762, 753, 744, 736, 728, 720, 712, 704, 697, 689, 682, 675, 668, 661, 655, 648, 642, 636, 630, 624, 618, 612, 606, 601, 595, 590, 585, 579, 574, 569, 564, 560, 555, 550, 546, 541, 537, 532, 528, 524, 520, 516, 512, 508, 504, 500, 496, 492, 489, 485, 481, 478, 474, 471, 468, 464, 461, 458, 455, 451, 448, 445, 442, 439, 436, 434, 431, 428, 425, 422, 420, 417, 414, 412, 409, 407, 404, 402, 399, 397, 394, 392, 390, 387, 385, 383, 381, 378, 376, 374, 372, 370, 368, 366, 364, 362, 360, 358, 356, 354, 352, 350, 348, 346, 344, 343, 341, 339, 337, 336, 334, 332, 330, 329, 327, 326, 324, 322, 321, 319, 318, 316, 315, 313, 312, 310, 309, 307, 306, 304, 303, 302, 300, 299, 297, 296, 295, 293, 292, 291, 289, 288, 287, 286, 284, 283, 282, 281, 280, 278, 277, 276, 275, 274, 273, 271, 270, 269, 268, 267, 266, 265, 264, 263, 262, 261, 260, 259, 258, 257, 256, 255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240, 240, 239, 238, 237, 236, 235, 234, 234, 233, 232, 231, 230, 229, 229, 228, 227, 226, 225, 225, 224, 223, 222, 222, 221, 220, 219, 219, 218, 217, 217, 216, 215, 214, 214, 213, 212, 212, 211, 210, 210, 209, 208, 208, 207, 206, 206, 205, 204, 204, 203, 202, 202, 201, 201, 200, 199, 199, 198, 197, 197, 196, 196, 195, 195, 194, 193, 193, 192, 192, 191, 191, 190, 189, 189, 188, 188, 187, 187, 186, 186, 185, 185, 184, 184, 183, 183, 182, 182, 181, 181, 180, 180, 179, 179, 178, 178, 177, 177, 176, 176, 175, 175, 174, 174, 173, 173, 172, 172, 172, 171, 171, 170, 170, 169, 169, 168, 168, 168, 167, 167, 166, 166, 165, 165, 165, 164, 164, 163, 163, 163, 162, 162, 161, 161, 161, 160, 160, 159, 159, 159, 158, 158, 157, 157, 157, 156, 156, 156, 155, 155, 154, 154, 154, 153, 153, 153, 152, 152, 152, 151, 151, 151, 150, 150, 149, 149, 149, 148, 148, 148, 147, 147, 147, 146, 146, 146, 145, 145, 145, 144, 144, 144, 144, 143, 143, 143, 142, 142, 142, 141, 141, 141, 140, 140, 140, 140, 139, 139, 139, 138, 138, 138, 137, 137, 137, 137, 136, 136, 136, 135, 135, 135, 135, 134, 134, 134, 134, 133, 133, 133, 132, 132, 132, 132, 131, 131, 131, 131, 130, 130, 130, 130, 129, 129, 129, 129, 128, 128, 128 }; const M4VIFI_Int32 const_storage1[8] = { 0x00002568, 0x00003343,0x00000649,0x00000d0f, 0x0000D86C, 0x0000D83B, 0x00010000, 0x00010000 }; const M4VIFI_Int32 const_storage[8] = { 0x00002568, 0x00003343, 0x1BF800, 0x00000649, 0x00000d0f, 0x110180, 0x40cf, 0x22BE00 }; const M4VIFI_UInt16 *M4VIFI_DivTable_zero = &M4VIFI_DivTable[0]; const M4VIFI_UInt8 *M4VIFI_ClipTable_zero = &M4VIFI_ClipTable[500]; M4VIFI_UInt8 M4VIFI_YUV420PlanarToYUV420Semiplanar(void *user_data, M4VIFI_ImagePlane *PlaneIn, M4VIFI_ImagePlane *PlaneOut ) { M4VIFI_UInt32 i; M4VIFI_UInt8 *p_buf_src, *p_buf_dest, *p_buf_src_u, *p_buf_src_v; M4VIFI_UInt8 return_code = M4VIFI_OK; /* the filter is implemented with the assumption that the width is equal to stride */ if(PlaneIn[0].u_width != PlaneIn[0].u_stride) return M4VIFI_INVALID_PARAM; /* The input Y Plane is the same as the output Y Plane */ p_buf_src = &(PlaneIn[0].pac_data[PlaneIn[0].u_topleft]); p_buf_dest = &(PlaneOut[0].pac_data[PlaneOut[0].u_topleft]); memcpy((void *)p_buf_dest,(void *)p_buf_src , PlaneOut[0].u_width * PlaneOut[0].u_height); /* The U and V components are planar. The need to be made interleaved */ p_buf_src_u = &(PlaneIn[1].pac_data[PlaneIn[1].u_topleft]); p_buf_src_v = &(PlaneIn[2].pac_data[PlaneIn[2].u_topleft]); p_buf_dest = &(PlaneOut[1].pac_data[PlaneOut[1].u_topleft]); for(i = 0; i < PlaneOut[1].u_width*PlaneOut[1].u_height; i++) { *p_buf_dest++ = *p_buf_src_u++; *p_buf_dest++ = *p_buf_src_v++; } return return_code; } M4VIFI_UInt8 M4VIFI_SemiplanarYUV420toYUV420(void *user_data, M4VIFI_ImagePlane *PlaneIn, M4VIFI_ImagePlane *PlaneOut ) { M4VIFI_UInt32 i; M4VIFI_UInt8 *p_buf_src, *p_buf_dest, *p_buf_src_u, *p_buf_src_v; M4VIFI_UInt8 *p_buf_dest_u,*p_buf_dest_v,*p_buf_src_uv; M4VIFI_UInt8 return_code = M4VIFI_OK; /* the filter is implemented with the assumption that the width is equal to stride */ if(PlaneIn[0].u_width != PlaneIn[0].u_stride) return M4VIFI_INVALID_PARAM; /* The input Y Plane is the same as the output Y Plane */ p_buf_src = &(PlaneIn[0].pac_data[PlaneIn[0].u_topleft]); p_buf_dest = &(PlaneOut[0].pac_data[PlaneOut[0].u_topleft]); memcpy((void *)p_buf_dest,(void *)p_buf_src , PlaneOut[0].u_width * PlaneOut[0].u_height); /* The U and V components are planar. The need to be made interleaved */ p_buf_src_uv = &(PlaneIn[1].pac_data[PlaneIn[1].u_topleft]); p_buf_dest_u = &(PlaneOut[1].pac_data[PlaneOut[1].u_topleft]); p_buf_dest_v = &(PlaneOut[2].pac_data[PlaneOut[2].u_topleft]); for(i = 0; i < PlaneOut[1].u_width*PlaneOut[1].u_height; i++) { *p_buf_dest_u++ = *p_buf_src_uv++; *p_buf_dest_v++ = *p_buf_src_uv++; } return return_code; } /** ****************************************************************************** * prototype M4VSS3GPP_externalVideoEffectColor(M4OSA_Void *pFunctionContext, * M4VIFI_ImagePlane *PlaneIn, * M4VIFI_ImagePlane *PlaneOut, * M4VSS3GPP_ExternalProgress *pProgress, * M4OSA_UInt32 uiEffectKind) * * @brief This function apply a color effect on an input YUV420 planar frame * @note * @param pFunctionContext(IN) Contains which color to apply (not very clean ...) * @param PlaneIn (IN) Input YUV420 planar * @param PlaneOut (IN/OUT) Output YUV420 planar * @param pProgress (IN/OUT) Progress indication (0-100) * @param uiEffectKind (IN) Unused * * @return M4VIFI_OK: No error ****************************************************************************** */ M4OSA_ERR M4VSS3GPP_externalVideoEffectColor(M4OSA_Void *pFunctionContext, M4VIFI_ImagePlane *PlaneIn, M4VIFI_ImagePlane *PlaneOut, M4VSS3GPP_ExternalProgress *pProgress, M4OSA_UInt32 uiEffectKind) { M4VIFI_Int32 plane_number; M4VIFI_UInt32 i,j; M4VIFI_UInt8 *p_buf_src, *p_buf_dest; M4xVSS_ColorStruct* ColorContext = (M4xVSS_ColorStruct*)pFunctionContext; for (plane_number = 0; plane_number < 3; plane_number++) { p_buf_src = &(PlaneIn[plane_number].pac_data[PlaneIn[plane_number].u_topleft]); p_buf_dest = &(PlaneOut[plane_number].pac_data[PlaneOut[plane_number].u_topleft]); for (i = 0; i < PlaneOut[plane_number].u_height; i++) { /** * Chrominance */ if(plane_number==1 || plane_number==2) { //switch ((M4OSA_UInt32)pFunctionContext) // commented because a structure for the effects context exist switch (ColorContext->colorEffectType) { case M4xVSS_kVideoEffectType_BlackAndWhite: memset((void *)p_buf_dest,128, PlaneIn[plane_number].u_width); break; case M4xVSS_kVideoEffectType_Pink: memset((void *)p_buf_dest,255, PlaneIn[plane_number].u_width); break; case M4xVSS_kVideoEffectType_Green: memset((void *)p_buf_dest,0, PlaneIn[plane_number].u_width); break; case M4xVSS_kVideoEffectType_Sepia: if(plane_number==1) { memset((void *)p_buf_dest,117, PlaneIn[plane_number].u_width); } else { memset((void *)p_buf_dest,139, PlaneIn[plane_number].u_width); } break; case M4xVSS_kVideoEffectType_Negative: memcpy((void *)p_buf_dest, (void *)p_buf_src ,PlaneOut[plane_number].u_width); break; case M4xVSS_kVideoEffectType_ColorRGB16: { M4OSA_UInt16 r = 0,g = 0,b = 0,y = 0,u = 0,v = 0; /*first get the r, g, b*/ b = (ColorContext->rgb16ColorData & 0x001f); g = (ColorContext->rgb16ColorData & 0x07e0)>>5; r = (ColorContext->rgb16ColorData & 0xf800)>>11; /*keep y, but replace u and v*/ if(plane_number==1) { /*then convert to u*/ u = U16(r, g, b); memset((void *)p_buf_dest,(M4OSA_UInt8)u, PlaneIn[plane_number].u_width); } if(plane_number==2) { /*then convert to v*/ v = V16(r, g, b); memset((void *)p_buf_dest,(M4OSA_UInt8)v, PlaneIn[plane_number].u_width); } } break; case M4xVSS_kVideoEffectType_Gradient: { M4OSA_UInt16 r = 0,g = 0,b = 0,y = 0,u = 0,v = 0; /*first get the r, g, b*/ b = (ColorContext->rgb16ColorData & 0x001f); g = (ColorContext->rgb16ColorData & 0x07e0)>>5; r = (ColorContext->rgb16ColorData & 0xf800)>>11; /*for color gradation*/ b = (M4OSA_UInt16)( b - ((b*i)/PlaneIn[plane_number].u_height)); g = (M4OSA_UInt16)(g - ((g*i)/PlaneIn[plane_number].u_height)); r = (M4OSA_UInt16)(r - ((r*i)/PlaneIn[plane_number].u_height)); /*keep y, but replace u and v*/ if(plane_number==1) { /*then convert to u*/ u = U16(r, g, b); memset((void *)p_buf_dest,(M4OSA_UInt8)u, PlaneIn[plane_number].u_width); } if(plane_number==2) { /*then convert to v*/ v = V16(r, g, b); memset((void *)p_buf_dest,(M4OSA_UInt8)v, PlaneIn[plane_number].u_width); } } break; default: return M4VIFI_INVALID_PARAM; } } /** * Luminance */ else { //switch ((M4OSA_UInt32)pFunctionContext)// commented because a structure for the effects context exist switch (ColorContext->colorEffectType) { case M4xVSS_kVideoEffectType_Negative: for(j=0;j>8); M4OSA_UInt8 transparent2 = (M4OSA_UInt8)TRANSPARENT_COLOR; #ifndef DECODE_GIF_ON_SAVING Framing = (M4xVSS_FramingStruct *)userData; currentFraming = (M4xVSS_FramingStruct *)Framing->pCurrent; FramingRGB = Framing->FramingRgb->pac_data; #endif /*DECODE_GIF_ON_SAVING*/ #ifdef DECODE_GIF_ON_SAVING M4OSA_ERR err; Framing = (M4xVSS_FramingStruct *)((M4xVSS_FramingContext*)userData)->aFramingCtx; if(Framing == M4OSA_NULL) { ((M4xVSS_FramingContext*)userData)->clipTime = pProgress->uiOutputTime; err = M4xVSS_internalDecodeGIF(userData); if(M4NO_ERROR != err) { M4OSA_TRACE1_1("M4VSS3GPP_externalVideoEffectFraming: \ Error in M4xVSS_internalDecodeGIF: 0x%x", err); return err; } Framing = (M4xVSS_FramingStruct *)((M4xVSS_FramingContext*)userData)->aFramingCtx; /* Initializes first GIF time */ ((M4xVSS_FramingContext*)userData)->current_gif_time = pProgress->uiOutputTime; } currentFraming = (M4xVSS_FramingStruct *)Framing; FramingRGB = Framing->FramingRgb->pac_data; #endif /*DECODE_GIF_ON_SAVING*/ /** * Initialize input / output plane pointers */ p_in_Y += PlaneIn[0].u_topleft; p_in_U += PlaneIn[1].u_topleft; p_in_V += PlaneIn[2].u_topleft; p_out0 = PlaneOut[0].pac_data; p_out1 = PlaneOut[1].pac_data; p_out2 = PlaneOut[2].pac_data; /** * Depending on time, initialize Framing frame to use */ if(Framing->previousClipTime == -1) { Framing->previousClipTime = pProgress->uiOutputTime; } /** * If the current clip time has reach the duration of one frame of the framing picture * we need to step to next framing picture */ #ifdef DECODE_GIF_ON_SAVING if(((M4xVSS_FramingContext*)userData)->b_animated == M4OSA_TRUE) { while((((M4xVSS_FramingContext*)userData)->current_gif_time + currentFraming->duration) < pProgress->uiOutputTime) { ((M4xVSS_FramingContext*)userData)->clipTime = pProgress->uiOutputTime; err = M4xVSS_internalDecodeGIF(userData); if(M4NO_ERROR != err) { M4OSA_TRACE1_1("M4VSS3GPP_externalVideoEffectFraming: Error in M4xVSS_internalDecodeGIF: 0x%x", err); return err; } if(currentFraming->duration != 0) { ((M4xVSS_FramingContext*)userData)->current_gif_time += currentFraming->duration; } else { ((M4xVSS_FramingContext*)userData)->current_gif_time += pProgress->uiOutputTime - Framing->previousClipTime; } Framing = (M4xVSS_FramingStruct *)((M4xVSS_FramingContext*)userData)->aFramingCtx; currentFraming = (M4xVSS_FramingStruct *)Framing; FramingRGB = Framing->FramingRgb->pac_data; } } #else Framing->pCurrent = currentFraming->pNext; currentFraming = (M4xVSS_FramingStruct*)Framing->pCurrent; #endif /*DECODE_GIF_ON_SAVING*/ Framing->previousClipTime = pProgress->uiOutputTime; FramingRGB = currentFraming->FramingRgb->pac_data; topleft[0] = currentFraming->topleft_x; topleft[1] = currentFraming->topleft_y; for( x=0 ;x < PlaneIn[0].u_height ; x++) { for( y=0 ;y < PlaneIn[0].u_width ; y++) { /** * To handle framing with input size != output size * Framing is applyed if coordinates matches between framing/topleft and input plane */ if( y < (topleft[0] + currentFraming->FramingYuv[0].u_width) && y >= topleft[0] && x < (topleft[1] + currentFraming->FramingYuv[0].u_height) && x >= topleft[1]) { /*Alpha blending support*/ M4OSA_Float alphaBlending = 1; #ifdef DECODE_GIF_ON_SAVING M4xVSS_internalEffectsAlphaBlending* alphaBlendingStruct = (M4xVSS_internalEffectsAlphaBlending*)((M4xVSS_FramingContext*)userData)->alphaBlendingStruct; #else M4xVSS_internalEffectsAlphaBlending* alphaBlendingStruct = (M4xVSS_internalEffectsAlphaBlending*)((M4xVSS_FramingStruct*)userData)->alphaBlendingStruct; #endif //#ifdef DECODE_GIF_ON_SAVING if(alphaBlendingStruct != M4OSA_NULL) { if(pProgress->uiProgress < (M4OSA_UInt32)(alphaBlendingStruct->m_fadeInTime*10)) { alphaBlending = ((M4OSA_Float)(alphaBlendingStruct->m_middle - alphaBlendingStruct->m_start)*pProgress->uiProgress/(alphaBlendingStruct->m_fadeInTime*10)); alphaBlending += alphaBlendingStruct->m_start; alphaBlending /= 100; } else if(pProgress->uiProgress >= (M4OSA_UInt32)(alphaBlendingStruct->m_fadeInTime*10) && pProgress->uiProgress < 1000 - (M4OSA_UInt32)(alphaBlendingStruct->m_fadeOutTime*10)) { alphaBlending = (M4OSA_Float)((M4OSA_Float)alphaBlendingStruct->m_middle/100); } else if(pProgress->uiProgress >= 1000 - (M4OSA_UInt32)(alphaBlendingStruct->m_fadeOutTime*10)) { alphaBlending = ((M4OSA_Float)(alphaBlendingStruct->m_middle - alphaBlendingStruct->m_end))*(1000 - pProgress->uiProgress)/(alphaBlendingStruct->m_fadeOutTime*10); alphaBlending += alphaBlendingStruct->m_end; alphaBlending /= 100; } } /**/ if((*(FramingRGB)==transparent1) && (*(FramingRGB+1)==transparent2)) { *( p_out0+y+x*PlaneOut[0].u_stride)=(*(p_in_Y+y+x*PlaneIn[0].u_stride)); *( p_out1+(y>>1)+(x>>1)*PlaneOut[1].u_stride)=(*(p_in_U+(y>>1)+(x>>1)*PlaneIn[1].u_stride)); *( p_out2+(y>>1)+(x>>1)*PlaneOut[2].u_stride)=(*(p_in_V+(y>>1)+(x>>1)*PlaneIn[2].u_stride)); } else { *( 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; *( p_out0+y+x*PlaneOut[0].u_stride)+=(*(p_in_Y+y+x*PlaneIn[0].u_stride))*(1-alphaBlending); *( 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; *( p_out1+(y>>1)+(x>>1)*PlaneOut[1].u_stride)+=(*(p_in_U+(y>>1)+(x>>1)*PlaneIn[1].u_stride))*(1-alphaBlending); *( 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; *( p_out2+(y>>1)+(x>>1)*PlaneOut[2].u_stride)+=(*(p_in_V+(y>>1)+(x>>1)*PlaneIn[2].u_stride))*(1-alphaBlending); } if( PlaneIn[0].u_width < (topleft[0] + currentFraming->FramingYuv[0].u_width) && y == PlaneIn[0].u_width-1) { FramingRGB = FramingRGB + 2 * (topleft[0] + currentFraming->FramingYuv[0].u_width - PlaneIn[0].u_width + 1); } else { FramingRGB = FramingRGB + 2; } } /** * Just copy input plane to output plane */ else { *( p_out0+y+x*PlaneOut[0].u_stride)=*(p_in_Y+y+x*PlaneIn[0].u_stride); *( p_out1+(y>>1)+(x>>1)*PlaneOut[1].u_stride)=*(p_in_U+(y>>1)+(x>>1)*PlaneIn[1].u_stride); *( p_out2+(y>>1)+(x>>1)*PlaneOut[2].u_stride)=*(p_in_V+(y>>1)+(x>>1)*PlaneIn[2].u_stride); } } } #ifdef DECODE_GIF_ON_SAVING if(pProgress->bIsLast == M4OSA_TRUE && (M4OSA_Bool)((M4xVSS_FramingContext*)userData)->b_IsFileGif == M4OSA_TRUE) { M4xVSS_internalDecodeGIF_Cleaning((M4xVSS_FramingContext*)userData); } #endif /*DECODE_GIF_ON_SAVING*/ return M4VIFI_OK; } /** ****************************************************************************** * prototype M4VSS3GPP_externalVideoEffectFifties(M4OSA_Void *pFunctionContext, * M4VIFI_ImagePlane *PlaneIn, * M4VIFI_ImagePlane *PlaneOut, * M4VSS3GPP_ExternalProgress *pProgress, * M4OSA_UInt32 uiEffectKind) * * @brief This function make a video look as if it was taken in the fifties * @note * @param pUserData (IN) Context * @param pPlaneIn (IN) Input YUV420 planar * @param pPlaneOut (IN/OUT) Output YUV420 planar * @param pProgress (IN/OUT) Progress indication (0-100) * @param uiEffectKind (IN) Unused * * @return M4VIFI_OK: No error * @return M4ERR_PARAMETER: pFiftiesData, pPlaneOut or pProgress are NULL (DEBUG only) ****************************************************************************** */ M4OSA_ERR M4VSS3GPP_externalVideoEffectFifties( M4OSA_Void *pUserData, M4VIFI_ImagePlane *pPlaneIn, M4VIFI_ImagePlane *pPlaneOut, M4VSS3GPP_ExternalProgress *pProgress, M4OSA_UInt32 uiEffectKind ) { M4VIFI_UInt32 x, y, xShift; M4VIFI_UInt8 *pInY = pPlaneIn[0].pac_data; M4VIFI_UInt8 *pOutY, *pInYbegin; M4VIFI_UInt8 *pInCr,* pOutCr; M4VIFI_Int32 plane_number; /* Internal context*/ M4xVSS_FiftiesStruct* p_FiftiesData = (M4xVSS_FiftiesStruct *)pUserData; /* Initialize input / output plane pointers */ pInY += pPlaneIn[0].u_topleft; pOutY = pPlaneOut[0].pac_data; pInYbegin = pInY; /* Initialize the random */ if(p_FiftiesData->previousClipTime < 0) { M4OSA_randInit(); M4OSA_rand((M4OSA_Int32*)&(p_FiftiesData->shiftRandomValue), (pPlaneIn[0].u_height) >> 4); M4OSA_rand((M4OSA_Int32*)&(p_FiftiesData->stripeRandomValue), (pPlaneIn[0].u_width)<< 2); p_FiftiesData->previousClipTime = pProgress->uiOutputTime; } /* Choose random values if we have reached the duration of a partial effect */ else if( (pProgress->uiOutputTime - p_FiftiesData->previousClipTime) > p_FiftiesData->fiftiesEffectDuration) { M4OSA_rand((M4OSA_Int32*)&(p_FiftiesData->shiftRandomValue), (pPlaneIn[0].u_height) >> 4); M4OSA_rand((M4OSA_Int32*)&(p_FiftiesData->stripeRandomValue), (pPlaneIn[0].u_width)<< 2); p_FiftiesData->previousClipTime = pProgress->uiOutputTime; } /* Put in Sepia the chrominance */ for (plane_number = 1; plane_number < 3; plane_number++) { pInCr = pPlaneIn[plane_number].pac_data + pPlaneIn[plane_number].u_topleft; pOutCr = pPlaneOut[plane_number].pac_data + pPlaneOut[plane_number].u_topleft; for (x = 0; x < pPlaneOut[plane_number].u_height; x++) { if (1 == plane_number) memset((void *)pOutCr, 117,pPlaneIn[plane_number].u_width); /* U value */ else memset((void *)pOutCr, 139,pPlaneIn[plane_number].u_width); /* V value */ pInCr += pPlaneIn[plane_number].u_stride; pOutCr += pPlaneOut[plane_number].u_stride; } } /* Compute the new pixels values */ for( x = 0 ; x < pPlaneIn[0].u_height ; x++) { M4VIFI_UInt8 *p_outYtmp, *p_inYtmp; /* Compute the xShift (random value) */ if (0 == (p_FiftiesData->shiftRandomValue % 5 )) xShift = (x + p_FiftiesData->shiftRandomValue ) % (pPlaneIn[0].u_height - 1); else xShift = (x + (pPlaneIn[0].u_height - p_FiftiesData->shiftRandomValue) ) % (pPlaneIn[0].u_height - 1); /* Initialize the pointers */ p_outYtmp = pOutY + 1; /* yShift of 1 pixel */ p_inYtmp = pInYbegin + (xShift * pPlaneIn[0].u_stride); /* Apply the xShift */ for( y = 0 ; y < pPlaneIn[0].u_width ; y++) { /* Set Y value */ if (xShift > (pPlaneIn[0].u_height - 4)) *p_outYtmp = 40; /* Add some horizontal black lines between the two parts of the image */ else if ( y == p_FiftiesData->stripeRandomValue) *p_outYtmp = 90; /* Add a random vertical line for the bulk */ else *p_outYtmp = *p_inYtmp; /* Go to the next pixel */ p_outYtmp++; p_inYtmp++; /* Restart at the beginning of the line for the last pixel*/ if (y == (pPlaneIn[0].u_width - 2)) p_outYtmp = pOutY; } /* Go to the next line */ pOutY += pPlaneOut[0].u_stride; } return M4VIFI_OK; } unsigned char M4VFL_modifyLumaWithScale(M4ViComImagePlane *plane_in, M4ViComImagePlane *plane_out, unsigned long lum_factor, void *user_data) { unsigned short *p_src, *p_dest, *p_src_line, *p_dest_line; unsigned char *p_csrc, *p_cdest, *p_csrc_line, *p_cdest_line; unsigned long pix_src; unsigned long u_outpx, u_outpx2; unsigned long u_width, u_stride, u_stride_out,u_height, pix; long i, j; /* copy or filter chroma */ u_width = plane_in[1].u_width; u_height = plane_in[1].u_height; u_stride = plane_in[1].u_stride; u_stride_out = plane_out[1].u_stride; p_cdest_line = (unsigned char *) &plane_out[1].pac_data[plane_out[1].u_topleft]; p_csrc_line = (unsigned char *) &plane_in[1].pac_data[plane_in[1].u_topleft]; if (lum_factor > 256) { p_cdest = (unsigned char *) &plane_out[2].pac_data[plane_out[2].u_topleft]; p_csrc = (unsigned char *) &plane_in[2].pac_data[plane_in[2].u_topleft]; /* copy chroma */ for (j = u_height; j != 0; j--) { for (i = u_width; i != 0; i--) { memcpy((void *)p_cdest_line, (void *)p_csrc_line, u_width); memcpy((void *)p_cdest, (void *)p_csrc, u_width); } p_cdest_line += u_stride_out; p_cdest += u_stride_out; p_csrc_line += u_stride; p_csrc += u_stride; } } else { /* filter chroma */ pix = (1024 - lum_factor) << 7; for (j = u_height; j != 0; j--) { p_cdest = p_cdest_line; p_csrc = p_csrc_line; for (i = u_width; i != 0; i--) { *p_cdest++ = ((pix + (*p_csrc++ & 0xFF) * lum_factor) >> LUM_FACTOR_MAX); } p_cdest_line += u_stride_out; p_csrc_line += u_stride; } p_cdest_line = (unsigned char *) &plane_out[2].pac_data[plane_out[2].u_topleft]; p_csrc_line = (unsigned char *) &plane_in[2].pac_data[plane_in[2].u_topleft]; for (j = u_height; j != 0; j--) { p_cdest = p_cdest_line; p_csrc = p_csrc_line; for (i = u_width; i != 0; i--) { *p_cdest++ = ((pix + (*p_csrc & 0xFF) * lum_factor) >> LUM_FACTOR_MAX); } p_cdest_line += u_stride_out; p_csrc_line += u_stride; } } /* apply luma factor */ u_width = plane_in[0].u_width; u_height = plane_in[0].u_height; u_stride = (plane_in[0].u_stride >> 1); u_stride_out = (plane_out[0].u_stride >> 1); p_dest = (unsigned short *) &plane_out[0].pac_data[plane_out[0].u_topleft]; p_src = (unsigned short *) &plane_in[0].pac_data[plane_in[0].u_topleft]; p_dest_line = p_dest; p_src_line = p_src; for (j = u_height; j != 0; j--) { p_dest = p_dest_line; p_src = p_src_line; for (i = (u_width >> 1); i != 0; i--) { pix_src = (unsigned long) *p_src++; pix = pix_src & 0xFF; u_outpx = ((pix * lum_factor) >> LUM_FACTOR_MAX); pix = ((pix_src & 0xFF00) >> 8); u_outpx2 = (((pix * lum_factor) >> LUM_FACTOR_MAX)<< 8) ; *p_dest++ = (unsigned short) (u_outpx2 | u_outpx); } p_dest_line += u_stride_out; p_src_line += u_stride; } return 0; } /****************************************************************************** * prototype M4OSA_ERR M4xVSS_internalConvertRGBtoYUV(M4xVSS_FramingStruct* framingCtx) * @brief This function converts an RGB565 plane to YUV420 planar * @note It is used only for framing effect * It allocates output YUV planes * @param framingCtx (IN) The framing struct containing input RGB565 plane * * @return M4NO_ERROR: No error * @return M4ERR_PARAMETER: At least one of the function parameters is null * @return M4ERR_ALLOC: Allocation error (no more memory) ****************************************************************************** */ M4OSA_ERR M4xVSS_internalConvertRGBtoYUV(M4xVSS_FramingStruct* framingCtx) { M4OSA_ERR err; /** * Allocate output YUV planes */ framingCtx->FramingYuv = (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc(3*sizeof(M4VIFI_ImagePlane), M4VS, (M4OSA_Char*)"M4xVSS_internalConvertRGBtoYUV: Output plane YUV"); if(framingCtx->FramingYuv == M4OSA_NULL) { M4OSA_TRACE1_0("Allocation error in M4xVSS_internalConvertRGBtoYUV"); return M4ERR_ALLOC; } framingCtx->FramingYuv[0].u_width = framingCtx->FramingRgb->u_width; framingCtx->FramingYuv[0].u_height = framingCtx->FramingRgb->u_height; framingCtx->FramingYuv[0].u_topleft = 0; framingCtx->FramingYuv[0].u_stride = framingCtx->FramingRgb->u_width; 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");; if(framingCtx->FramingYuv[0].pac_data == M4OSA_NULL) { M4OSA_TRACE1_0("Allocation error in M4xVSS_internalConvertRGBtoYUV"); return M4ERR_ALLOC; } framingCtx->FramingYuv[1].u_width = (framingCtx->FramingRgb->u_width)>>1; framingCtx->FramingYuv[1].u_height = (framingCtx->FramingRgb->u_height)>>1; framingCtx->FramingYuv[1].u_topleft = 0; framingCtx->FramingYuv[1].u_stride = (framingCtx->FramingRgb->u_width)>>1; framingCtx->FramingYuv[1].pac_data = framingCtx->FramingYuv[0].pac_data + framingCtx->FramingYuv[0].u_width * framingCtx->FramingYuv[0].u_height; framingCtx->FramingYuv[2].u_width = (framingCtx->FramingRgb->u_width)>>1; framingCtx->FramingYuv[2].u_height = (framingCtx->FramingRgb->u_height)>>1; framingCtx->FramingYuv[2].u_topleft = 0; framingCtx->FramingYuv[2].u_stride = (framingCtx->FramingRgb->u_width)>>1; framingCtx->FramingYuv[2].pac_data = framingCtx->FramingYuv[1].pac_data + framingCtx->FramingYuv[1].u_width * framingCtx->FramingYuv[1].u_height; /** * Convert input RGB 565 to YUV 420 to be able to merge it with output video in framing effect */ err = M4VIFI_xVSS_RGB565toYUV420(M4OSA_NULL, framingCtx->FramingRgb, framingCtx->FramingYuv); if(err != M4NO_ERROR) { M4OSA_TRACE1_1("M4xVSS_internalConvertRGBtoYUV: error when converting from RGB to YUV: 0x%x\n", err); } framingCtx->duration = 0; framingCtx->previousClipTime = -1; framingCtx->previewOffsetClipTime = -1; /** * Only one element in the chained list (no animated image with RGB buffer...) */ framingCtx->pCurrent = framingCtx; framingCtx->pNext = framingCtx; return M4NO_ERROR; } /****************************************************************************** * prototype M4OSA_ERR M4xVSS_internalConvertRGB888toYUV(M4xVSS_FramingStruct* framingCtx) * @brief This function converts an RGB888 plane to YUV420 planar * @note It is used only for framing effect * It allocates output YUV planes * @param framingCtx (IN) The framing struct containing input RGB888 plane * * @return M4NO_ERROR: No error * @return M4ERR_PARAMETER: At least one of the function parameters is null * @return M4ERR_ALLOC: Allocation error (no more memory) ****************************************************************************** */ M4OSA_ERR M4xVSS_internalConvertRGB888toYUV(M4xVSS_FramingStruct* framingCtx) { M4OSA_ERR err; /** * Allocate output YUV planes */ framingCtx->FramingYuv = (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc(3*sizeof(M4VIFI_ImagePlane), M4VS, (M4OSA_Char*)"M4xVSS_internalConvertRGBtoYUV: Output plane YUV"); if(framingCtx->FramingYuv == M4OSA_NULL) { M4OSA_TRACE1_0("Allocation error in M4xVSS_internalConvertRGBtoYUV"); return M4ERR_ALLOC; } framingCtx->FramingYuv[0].u_width = framingCtx->FramingRgb->u_width; framingCtx->FramingYuv[0].u_height = framingCtx->FramingRgb->u_height; framingCtx->FramingYuv[0].u_topleft = 0; framingCtx->FramingYuv[0].u_stride = framingCtx->FramingRgb->u_width; 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");; if(framingCtx->FramingYuv[0].pac_data == M4OSA_NULL) { M4OSA_TRACE1_0("Allocation error in M4xVSS_internalConvertRGBtoYUV"); return M4ERR_ALLOC; } framingCtx->FramingYuv[1].u_width = (framingCtx->FramingRgb->u_width)>>1; framingCtx->FramingYuv[1].u_height = (framingCtx->FramingRgb->u_height)>>1; framingCtx->FramingYuv[1].u_topleft = 0; framingCtx->FramingYuv[1].u_stride = (framingCtx->FramingRgb->u_width)>>1; framingCtx->FramingYuv[1].pac_data = framingCtx->FramingYuv[0].pac_data + framingCtx->FramingYuv[0].u_width * framingCtx->FramingYuv[0].u_height; framingCtx->FramingYuv[2].u_width = (framingCtx->FramingRgb->u_width)>>1; framingCtx->FramingYuv[2].u_height = (framingCtx->FramingRgb->u_height)>>1; framingCtx->FramingYuv[2].u_topleft = 0; framingCtx->FramingYuv[2].u_stride = (framingCtx->FramingRgb->u_width)>>1; framingCtx->FramingYuv[2].pac_data = framingCtx->FramingYuv[1].pac_data + framingCtx->FramingYuv[1].u_width * framingCtx->FramingYuv[1].u_height; /** * Convert input RGB888 to YUV 420 to be able to merge it with output video in framing effect */ err = M4VIFI_RGB888toYUV420(M4OSA_NULL, framingCtx->FramingRgb, framingCtx->FramingYuv); if(err != M4NO_ERROR) { M4OSA_TRACE1_1("M4xVSS_internalConvertRGBtoYUV: error when converting from RGB to YUV: 0x%x\n", err); } framingCtx->duration = 0; framingCtx->previousClipTime = -1; framingCtx->previewOffsetClipTime = -1; /** * Only one element in the chained list (no animated image with RGB buffer...) */ framingCtx->pCurrent = framingCtx; framingCtx->pNext = framingCtx; return M4NO_ERROR; } /** ****************************************************************************** * M4VIFI_UInt8 M4VIFI_RGB565toYUV420 (void *pUserData, * M4VIFI_ImagePlane *pPlaneIn, * M4VIFI_ImagePlane *pPlaneOut) * @author Patrice Martinez / Philips Digital Networks - MP4Net * @brief transform RGB565 image to a YUV420 image. * @note Convert RGB565 to YUV420, * Loop on each row ( 2 rows by 2 rows ) * Loop on each column ( 2 col by 2 col ) * Get 4 RGB samples from input data and build 4 output Y samples * and each single U & V data * end loop on col * end loop on row * @param pUserData: (IN) User Specific Data * @param pPlaneIn: (IN) Pointer to RGB565 Plane * @param pPlaneOut: (OUT) Pointer to YUV420 buffer Plane * @return M4VIFI_OK: there is no error * @return M4VIFI_ILLEGAL_FRAME_HEIGHT: YUV Plane height is ODD * @return M4VIFI_ILLEGAL_FRAME_WIDTH: YUV Plane width is ODD ****************************************************************************** */ M4VIFI_UInt8 M4VIFI_xVSS_RGB565toYUV420(void *pUserData, M4VIFI_ImagePlane *pPlaneIn, M4VIFI_ImagePlane *pPlaneOut) { M4VIFI_UInt32 u32_width, u32_height; M4VIFI_UInt32 u32_stride_Y, u32_stride2_Y, u32_stride_U, u32_stride_V; M4VIFI_UInt32 u32_stride_rgb, u32_stride_2rgb; M4VIFI_UInt32 u32_col, u32_row; M4VIFI_Int32 i32_r00, i32_r01, i32_r10, i32_r11; M4VIFI_Int32 i32_g00, i32_g01, i32_g10, i32_g11; M4VIFI_Int32 i32_b00, i32_b01, i32_b10, i32_b11; M4VIFI_Int32 i32_y00, i32_y01, i32_y10, i32_y11; M4VIFI_Int32 i32_u00, i32_u01, i32_u10, i32_u11; M4VIFI_Int32 i32_v00, i32_v01, i32_v10, i32_v11; M4VIFI_UInt8 *pu8_yn, *pu8_ys, *pu8_u, *pu8_v; M4VIFI_UInt8 *pu8_y_data, *pu8_u_data, *pu8_v_data; M4VIFI_UInt8 *pu8_rgbn_data, *pu8_rgbn; M4VIFI_UInt16 u16_pix1, u16_pix2, u16_pix3, u16_pix4; M4VIFI_UInt8 count_null=0; /* Check planes height are appropriate */ if( (pPlaneIn->u_height != pPlaneOut[0].u_height) || (pPlaneOut[0].u_height != (pPlaneOut[1].u_height<<1)) || (pPlaneOut[0].u_height != (pPlaneOut[2].u_height<<1))) { return M4VIFI_ILLEGAL_FRAME_HEIGHT; } /* Check planes width are appropriate */ if( (pPlaneIn->u_width != pPlaneOut[0].u_width) || (pPlaneOut[0].u_width != (pPlaneOut[1].u_width<<1)) || (pPlaneOut[0].u_width != (pPlaneOut[2].u_width<<1))) { return M4VIFI_ILLEGAL_FRAME_WIDTH; } /* Set the pointer to the beginning of the output data buffers */ pu8_y_data = pPlaneOut[0].pac_data + pPlaneOut[0].u_topleft; pu8_u_data = pPlaneOut[1].pac_data + pPlaneOut[1].u_topleft; pu8_v_data = pPlaneOut[2].pac_data + pPlaneOut[2].u_topleft; /* Set the pointer to the beginning of the input data buffers */ pu8_rgbn_data = pPlaneIn->pac_data + pPlaneIn->u_topleft; /* Get the size of the output image */ u32_width = pPlaneOut[0].u_width; u32_height = pPlaneOut[0].u_height; /* Set the size of the memory jumps corresponding to row jump in each output plane */ u32_stride_Y = pPlaneOut[0].u_stride; u32_stride2_Y = u32_stride_Y << 1; u32_stride_U = pPlaneOut[1].u_stride; u32_stride_V = pPlaneOut[2].u_stride; /* Set the size of the memory jumps corresponding to row jump in input plane */ u32_stride_rgb = pPlaneIn->u_stride; u32_stride_2rgb = u32_stride_rgb << 1; /* Loop on each row of the output image, input coordinates are estimated from output ones */ /* Two YUV rows are computed at each pass */ for (u32_row = u32_height ;u32_row != 0; u32_row -=2) { /* Current Y plane row pointers */ pu8_yn = pu8_y_data; /* Next Y plane row pointers */ pu8_ys = pu8_yn + u32_stride_Y; /* Current U plane row pointer */ pu8_u = pu8_u_data; /* Current V plane row pointer */ pu8_v = pu8_v_data; pu8_rgbn = pu8_rgbn_data; /* Loop on each column of the output image */ for (u32_col = u32_width; u32_col != 0 ; u32_col -=2) { /* Get four RGB 565 samples from input data */ u16_pix1 = *( (M4VIFI_UInt16 *) pu8_rgbn); u16_pix2 = *( (M4VIFI_UInt16 *) (pu8_rgbn + CST_RGB_16_SIZE)); u16_pix3 = *( (M4VIFI_UInt16 *) (pu8_rgbn + u32_stride_rgb)); u16_pix4 = *( (M4VIFI_UInt16 *) (pu8_rgbn + u32_stride_rgb + CST_RGB_16_SIZE)); /* Unpack RGB565 to 8bit R, G, B */ /* (x,y) */ GET_RGB565(i32_b00,i32_g00,i32_r00,u16_pix1); /* (x+1,y) */ GET_RGB565(i32_b10,i32_g10,i32_r10,u16_pix2); /* (x,y+1) */ GET_RGB565(i32_b01,i32_g01,i32_r01,u16_pix3); /* (x+1,y+1) */ GET_RGB565(i32_b11,i32_g11,i32_r11,u16_pix4); /* If RGB is transparent color (0, 63, 0), we transform it to white (31,63,31) */ if(i32_b00 == 0 && i32_g00 == 63 && i32_r00 == 0) { i32_b00 = 31; i32_r00 = 31; } if(i32_b10 == 0 && i32_g10 == 63 && i32_r10 == 0) { i32_b10 = 31; i32_r10 = 31; } if(i32_b01 == 0 && i32_g01 == 63 && i32_r01 == 0) { i32_b01 = 31; i32_r01 = 31; } if(i32_b11 == 0 && i32_g11 == 63 && i32_r11 == 0) { i32_b11 = 31; i32_r11 = 31; } /* Convert RGB value to YUV */ i32_u00 = U16(i32_r00, i32_g00, i32_b00); i32_v00 = V16(i32_r00, i32_g00, i32_b00); /* luminance value */ i32_y00 = Y16(i32_r00, i32_g00, i32_b00); i32_u10 = U16(i32_r10, i32_g10, i32_b10); i32_v10 = V16(i32_r10, i32_g10, i32_b10); /* luminance value */ i32_y10 = Y16(i32_r10, i32_g10, i32_b10); i32_u01 = U16(i32_r01, i32_g01, i32_b01); i32_v01 = V16(i32_r01, i32_g01, i32_b01); /* luminance value */ i32_y01 = Y16(i32_r01, i32_g01, i32_b01); i32_u11 = U16(i32_r11, i32_g11, i32_b11); i32_v11 = V16(i32_r11, i32_g11, i32_b11); /* luminance value */ i32_y11 = Y16(i32_r11, i32_g11, i32_b11); /* Store luminance data */ pu8_yn[0] = (M4VIFI_UInt8)i32_y00; pu8_yn[1] = (M4VIFI_UInt8)i32_y10; pu8_ys[0] = (M4VIFI_UInt8)i32_y01; pu8_ys[1] = (M4VIFI_UInt8)i32_y11; *pu8_u = (M4VIFI_UInt8)((i32_u00 + i32_u01 + i32_u10 + i32_u11 + 2) >> 2); *pu8_v = (M4VIFI_UInt8)((i32_v00 + i32_v01 + i32_v10 + i32_v11 + 2) >> 2); /* Prepare for next column */ pu8_rgbn += (CST_RGB_16_SIZE<<1); /* Update current Y plane line pointer*/ pu8_yn += 2; /* Update next Y plane line pointer*/ pu8_ys += 2; /* Update U plane line pointer*/ pu8_u ++; /* Update V plane line pointer*/ pu8_v ++; } /* End of horizontal scanning */ /* Prepare pointers for the next row */ pu8_y_data += u32_stride2_Y; pu8_u_data += u32_stride_U; pu8_v_data += u32_stride_V; pu8_rgbn_data += u32_stride_2rgb; } /* End of vertical scanning */ return M4VIFI_OK; } /*************************************************************************** Proto: M4VIFI_UInt8 M4VIFI_RGB888toYUV420(void *pUserData, M4VIFI_ImagePlane *PlaneIn, M4VIFI_ImagePlane PlaneOut[3]); Author: Patrice Martinez / Philips Digital Networks - MP4Net Purpose: filling of the YUV420 plane from a BGR24 plane Abstract: Loop on each row ( 2 rows by 2 rows ) Loop on each column ( 2 col by 2 col ) Get 4 BGR samples from input data and build 4 output Y samples and each single U & V data end loop on col end loop on row In: RGB24 plane InOut: none Out: array of 3 M4VIFI_ImagePlane structures Modified: ML: RGB function modified to BGR. ***************************************************************************/ M4VIFI_UInt8 M4VIFI_RGB888toYUV420(void *pUserData, M4VIFI_ImagePlane *PlaneIn, M4VIFI_ImagePlane PlaneOut[3]) { M4VIFI_UInt32 u32_width, u32_height; M4VIFI_UInt32 u32_stride_Y, u32_stride2_Y, u32_stride_U, u32_stride_V, u32_stride_rgb, u32_stride_2rgb; M4VIFI_UInt32 u32_col, u32_row; M4VIFI_Int32 i32_r00, i32_r01, i32_r10, i32_r11; M4VIFI_Int32 i32_g00, i32_g01, i32_g10, i32_g11; M4VIFI_Int32 i32_b00, i32_b01, i32_b10, i32_b11; M4VIFI_Int32 i32_y00, i32_y01, i32_y10, i32_y11; M4VIFI_Int32 i32_u00, i32_u01, i32_u10, i32_u11; M4VIFI_Int32 i32_v00, i32_v01, i32_v10, i32_v11; M4VIFI_UInt8 *pu8_yn, *pu8_ys, *pu8_u, *pu8_v; M4VIFI_UInt8 *pu8_y_data, *pu8_u_data, *pu8_v_data; M4VIFI_UInt8 *pu8_rgbn_data, *pu8_rgbn; /* check sizes */ if( (PlaneIn->u_height != PlaneOut[0].u_height) || (PlaneOut[0].u_height != (PlaneOut[1].u_height<<1)) || (PlaneOut[0].u_height != (PlaneOut[2].u_height<<1))) return M4VIFI_ILLEGAL_FRAME_HEIGHT; if( (PlaneIn->u_width != PlaneOut[0].u_width) || (PlaneOut[0].u_width != (PlaneOut[1].u_width<<1)) || (PlaneOut[0].u_width != (PlaneOut[2].u_width<<1))) return M4VIFI_ILLEGAL_FRAME_WIDTH; /* set the pointer to the beginning of the output data buffers */ pu8_y_data = PlaneOut[0].pac_data + PlaneOut[0].u_topleft; pu8_u_data = PlaneOut[1].pac_data + PlaneOut[1].u_topleft; pu8_v_data = PlaneOut[2].pac_data + PlaneOut[2].u_topleft; /* idem for input buffer */ pu8_rgbn_data = PlaneIn->pac_data + PlaneIn->u_topleft; /* get the size of the output image */ u32_width = PlaneOut[0].u_width; u32_height = PlaneOut[0].u_height; /* set the size of the memory jumps corresponding to row jump in each output plane */ u32_stride_Y = PlaneOut[0].u_stride; u32_stride2_Y= u32_stride_Y << 1; u32_stride_U = PlaneOut[1].u_stride; u32_stride_V = PlaneOut[2].u_stride; /* idem for input plane */ u32_stride_rgb = PlaneIn->u_stride; u32_stride_2rgb = u32_stride_rgb << 1; /* loop on each row of the output image, input coordinates are estimated from output ones */ /* two YUV rows are computed at each pass */ for (u32_row = u32_height ;u32_row != 0; u32_row -=2) { /* update working pointers */ pu8_yn = pu8_y_data; pu8_ys = pu8_yn + u32_stride_Y; pu8_u = pu8_u_data; pu8_v = pu8_v_data; pu8_rgbn= pu8_rgbn_data; /* loop on each column of the output image*/ for (u32_col = u32_width; u32_col != 0 ; u32_col -=2) { /* get RGB samples of 4 pixels */ GET_RGB24(i32_r00, i32_g00, i32_b00, pu8_rgbn, 0); GET_RGB24(i32_r10, i32_g10, i32_b10, pu8_rgbn, CST_RGB_24_SIZE); GET_RGB24(i32_r01, i32_g01, i32_b01, pu8_rgbn, u32_stride_rgb); GET_RGB24(i32_r11, i32_g11, i32_b11, pu8_rgbn, u32_stride_rgb + CST_RGB_24_SIZE); i32_u00 = U24(i32_r00, i32_g00, i32_b00); i32_v00 = V24(i32_r00, i32_g00, i32_b00); i32_y00 = Y24(i32_r00, i32_g00, i32_b00); /* matrix luminance */ pu8_yn[0]= (M4VIFI_UInt8)i32_y00; i32_u10 = U24(i32_r10, i32_g10, i32_b10); i32_v10 = V24(i32_r10, i32_g10, i32_b10); i32_y10 = Y24(i32_r10, i32_g10, i32_b10); pu8_yn[1]= (M4VIFI_UInt8)i32_y10; i32_u01 = U24(i32_r01, i32_g01, i32_b01); i32_v01 = V24(i32_r01, i32_g01, i32_b01); i32_y01 = Y24(i32_r01, i32_g01, i32_b01); pu8_ys[0]= (M4VIFI_UInt8)i32_y01; i32_u11 = U24(i32_r11, i32_g11, i32_b11); i32_v11 = V24(i32_r11, i32_g11, i32_b11); i32_y11 = Y24(i32_r11, i32_g11, i32_b11); pu8_ys[1] = (M4VIFI_UInt8)i32_y11; *pu8_u = (M4VIFI_UInt8)((i32_u00 + i32_u01 + i32_u10 + i32_u11 + 2) >> 2); *pu8_v = (M4VIFI_UInt8)((i32_v00 + i32_v01 + i32_v10 + i32_v11 + 2) >> 2); pu8_rgbn += (CST_RGB_24_SIZE<<1); pu8_yn += 2; pu8_ys += 2; pu8_u ++; pu8_v ++; } /* end of horizontal scanning */ pu8_y_data += u32_stride2_Y; pu8_u_data += u32_stride_U; pu8_v_data += u32_stride_V; pu8_rgbn_data += u32_stride_2rgb; } /* End of vertical scanning */ return M4VIFI_OK; } /** YUV420 to YUV420 */ /** ******************************************************************************************* * M4VIFI_UInt8 M4VIFI_YUV420toYUV420 (void *pUserData, * M4VIFI_ImagePlane *pPlaneIn, * M4VIFI_ImagePlane *pPlaneOut) * @brief Transform YUV420 image to a YUV420 image. * @param pUserData: (IN) User Specific Data (Unused - could be NULL) * @param pPlaneIn: (IN) Pointer to YUV plane buffer * @param pPlaneOut: (OUT) Pointer to YUV Plane * @return M4VIFI_OK: there is no error * @return M4VIFI_ILLEGAL_FRAME_HEIGHT: Error in plane height * @return M4VIFI_ILLEGAL_FRAME_WIDTH: Error in plane width ******************************************************************************************* */ M4VIFI_UInt8 M4VIFI_YUV420toYUV420(void *user_data, M4VIFI_ImagePlane PlaneIn[3], M4VIFI_ImagePlane *PlaneOut ) { M4VIFI_Int32 plane_number; M4VIFI_UInt32 i; M4VIFI_UInt8 *p_buf_src, *p_buf_dest; for (plane_number = 0; plane_number < 3; plane_number++) { p_buf_src = &(PlaneIn[plane_number].pac_data[PlaneIn[plane_number].u_topleft]); p_buf_dest = &(PlaneOut[plane_number].pac_data[PlaneOut[plane_number].u_topleft]); for (i = 0; i < PlaneOut[plane_number].u_height; i++) { memcpy((void *)p_buf_dest, (void *)p_buf_src ,PlaneOut[plane_number].u_width); p_buf_src += PlaneIn[plane_number].u_stride; p_buf_dest += PlaneOut[plane_number].u_stride; } } return M4VIFI_OK; } /** *********************************************************************************************** * M4VIFI_UInt8 M4VIFI_ResizeBilinearYUV420toYUV420(void *pUserData, M4VIFI_ImagePlane *pPlaneIn, * M4VIFI_ImagePlane *pPlaneOut) * @author David Dana (PHILIPS Software) * @brief Resizes YUV420 Planar plane. * @note Basic structure of the function * Loop on each row (step 2) * Loop on each column (step 2) * Get four Y samples and 1 U & V sample * Resize the Y with corresponing U and V samples * Place the YUV in the ouput plane * end loop column * end loop row * For resizing bilinear interpolation linearly interpolates along * each row, and then uses that result in a linear interpolation down each column. * Each estimated pixel in the output image is a weighted * combination of its four neighbours. The ratio of compression * or dilatation is estimated using input and output sizes. * @param pUserData: (IN) User Data * @param pPlaneIn: (IN) Pointer to YUV420 (Planar) plane buffer * @param pPlaneOut: (OUT) Pointer to YUV420 (Planar) plane * @return M4VIFI_OK: there is no error * @return M4VIFI_ILLEGAL_FRAME_HEIGHT: Error in height * @return M4VIFI_ILLEGAL_FRAME_WIDTH: Error in width *********************************************************************************************** */ M4VIFI_UInt8 M4VIFI_ResizeBilinearYUV420toYUV420(void *pUserData, M4VIFI_ImagePlane *pPlaneIn, M4VIFI_ImagePlane *pPlaneOut) { M4VIFI_UInt8 *pu8_data_in, *pu8_data_out, *pu8dum; M4VIFI_UInt32 u32_plane; M4VIFI_UInt32 u32_width_in, u32_width_out, u32_height_in, u32_height_out; M4VIFI_UInt32 u32_stride_in, u32_stride_out; M4VIFI_UInt32 u32_x_inc, u32_y_inc; M4VIFI_UInt32 u32_x_accum, u32_y_accum, u32_x_accum_start; M4VIFI_UInt32 u32_width, u32_height; M4VIFI_UInt32 u32_y_frac; M4VIFI_UInt32 u32_x_frac; M4VIFI_UInt32 u32_temp_value; M4VIFI_UInt8 *pu8_src_top; M4VIFI_UInt8 *pu8_src_bottom; M4VIFI_UInt8 u8Wflag = 0; M4VIFI_UInt8 u8Hflag = 0; M4VIFI_UInt32 loop = 0; /* If input width is equal to output width and input height equal to output height then M4VIFI_YUV420toYUV420 is called. */ if ((pPlaneIn[0].u_height == pPlaneOut[0].u_height) && (pPlaneIn[0].u_width == pPlaneOut[0].u_width)) { return M4VIFI_YUV420toYUV420(pUserData, pPlaneIn, pPlaneOut); } /* Check for the YUV width and height are even */ if ((IS_EVEN(pPlaneIn[0].u_height) == FALSE) || (IS_EVEN(pPlaneOut[0].u_height) == FALSE)) { return M4VIFI_ILLEGAL_FRAME_HEIGHT; } if ((IS_EVEN(pPlaneIn[0].u_width) == FALSE) || (IS_EVEN(pPlaneOut[0].u_width) == FALSE)) { return M4VIFI_ILLEGAL_FRAME_WIDTH; } /* Loop on planes */ for(u32_plane = 0;u32_plane < PLANES;u32_plane++) { /* Set the working pointers at the beginning of the input/output data field */ pu8_data_in = pPlaneIn[u32_plane].pac_data + pPlaneIn[u32_plane].u_topleft; pu8_data_out = pPlaneOut[u32_plane].pac_data + pPlaneOut[u32_plane].u_topleft; /* Get the memory jump corresponding to a row jump */ u32_stride_in = pPlaneIn[u32_plane].u_stride; u32_stride_out = pPlaneOut[u32_plane].u_stride; /* Set the bounds of the active image */ u32_width_in = pPlaneIn[u32_plane].u_width; u32_height_in = pPlaneIn[u32_plane].u_height; u32_width_out = pPlaneOut[u32_plane].u_width; u32_height_out = pPlaneOut[u32_plane].u_height; /* For the case , width_out = width_in , set the flag to avoid accessing one column beyond the input width.In this case the last column is replicated for processing */ if (u32_width_out == u32_width_in) { u32_width_out = u32_width_out-1; u8Wflag = 1; } /* Compute horizontal ratio between src and destination width.*/ if (u32_width_out >= u32_width_in) { u32_x_inc = ((u32_width_in-1) * MAX_SHORT) / (u32_width_out-1); } else { u32_x_inc = (u32_width_in * MAX_SHORT) / (u32_width_out); } /* For the case , height_out = height_in , set the flag to avoid accessing one row beyond the input height.In this case the last row is replicated for processing */ if (u32_height_out == u32_height_in) { u32_height_out = u32_height_out-1; u8Hflag = 1; } /* Compute vertical ratio between src and destination height.*/ if (u32_height_out >= u32_height_in) { u32_y_inc = ((u32_height_in - 1) * MAX_SHORT) / (u32_height_out-1); } else { u32_y_inc = (u32_height_in * MAX_SHORT) / (u32_height_out); } /* Calculate initial accumulator value : u32_y_accum_start. u32_y_accum_start is coded on 15 bits, and represents a value between 0 and 0.5 */ if (u32_y_inc >= MAX_SHORT) { /* Keep the fractionnal part, assimung that integer part is coded on the 16 high bits and the fractional on the 15 low bits */ u32_y_accum = u32_y_inc & 0xffff; if (!u32_y_accum) { u32_y_accum = MAX_SHORT; } u32_y_accum >>= 1; } else { u32_y_accum = 0; } /* Calculate initial accumulator value : u32_x_accum_start. u32_x_accum_start is coded on 15 bits, and represents a value between 0 and 0.5 */ if (u32_x_inc >= MAX_SHORT) { u32_x_accum_start = u32_x_inc & 0xffff; if (!u32_x_accum_start) { u32_x_accum_start = MAX_SHORT; } u32_x_accum_start >>= 1; } else { u32_x_accum_start = 0; } u32_height = u32_height_out; /* Bilinear interpolation linearly interpolates along each row, and then uses that result in a linear interpolation donw each column. Each estimated pixel in the output image is a weighted combination of its four neighbours according to the formula: 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)+ f(p+&,q+1)R(1-a)R(b-1) with R(x) = / x+1 -1 =< x =< 0 \ 1-x 0 =< x =< 1 and a (resp. b)weighting coefficient is the distance from the nearest neighbor in the p (resp. q) direction */ do { /* Scan all the row */ /* Vertical weight factor */ u32_y_frac = (u32_y_accum>>12)&15; /* Reinit accumulator */ u32_x_accum = u32_x_accum_start; u32_width = u32_width_out; do { /* Scan along each row */ pu8_src_top = pu8_data_in + (u32_x_accum >> 16); pu8_src_bottom = pu8_src_top + u32_stride_in; u32_x_frac = (u32_x_accum >> 12)&15; /* Horizontal weight factor */ /* Weighted combination */ u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[0]*(16-u32_x_frac) + pu8_src_top[1]*u32_x_frac)*(16-u32_y_frac) + (pu8_src_bottom[0]*(16-u32_x_frac) + pu8_src_bottom[1]*u32_x_frac)*u32_y_frac )>>8); *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; /* Update horizontal accumulator */ u32_x_accum += u32_x_inc; } while(--u32_width); /* This u8Wflag flag gets in to effect if input and output width is same, and height may be different. So previous pixel is replicated here */ if (u8Wflag) { *pu8_data_out = (M4VIFI_UInt8)u32_temp_value; } pu8dum = (pu8_data_out-u32_width_out); pu8_data_out = pu8_data_out + u32_stride_out - u32_width_out; /* Update vertical accumulator */ u32_y_accum += u32_y_inc; if (u32_y_accum>>16) { pu8_data_in = pu8_data_in + (u32_y_accum >> 16) * u32_stride_in; u32_y_accum &= 0xffff; } } while(--u32_height); /* This u8Hflag flag gets in to effect if input and output height is same, and width may be different. So previous pixel row is replicated here */ if (u8Hflag) { for(loop =0; loop < (u32_width_out+u8Wflag); loop++) { *pu8_data_out++ = (M4VIFI_UInt8)*pu8dum++; } } } return M4VIFI_OK; } M4OSA_ERR applyRenderingMode(M4VIFI_ImagePlane* pPlaneIn, M4VIFI_ImagePlane* pPlaneOut, M4xVSS_MediaRendering mediaRendering) { M4OSA_ERR err = M4NO_ERROR; if(mediaRendering == M4xVSS_kResizing) { /** * Call the resize filter. From the intermediate frame to the encoder image plane */ err = M4VIFI_ResizeBilinearYUV420toYUV420(M4OSA_NULL, pPlaneIn, pPlaneOut); if (M4NO_ERROR != err) { M4OSA_TRACE1_1("applyRenderingMode: M4ViFilResizeBilinearYUV420toYUV420 returns 0x%x!", err); return err; } } else { M4AIR_Params Params; M4OSA_Context m_air_context; M4VIFI_ImagePlane pImagePlanesTemp[3]; M4VIFI_ImagePlane* pPlaneTemp; M4OSA_UInt8* pOutPlaneY = pPlaneOut[0].pac_data + pPlaneOut[0].u_topleft; M4OSA_UInt8* pOutPlaneU = pPlaneOut[1].pac_data + pPlaneOut[1].u_topleft; M4OSA_UInt8* pOutPlaneV = pPlaneOut[2].pac_data + pPlaneOut[2].u_topleft; M4OSA_UInt8* pInPlaneY = NULL; M4OSA_UInt8* pInPlaneU = NULL; M4OSA_UInt8* pInPlaneV = NULL; M4OSA_UInt32 i; /*to keep media aspect ratio*/ /*Initialize AIR Params*/ Params.m_inputCoord.m_x = 0; Params.m_inputCoord.m_y = 0; Params.m_inputSize.m_height = pPlaneIn->u_height; Params.m_inputSize.m_width = pPlaneIn->u_width; Params.m_outputSize.m_width = pPlaneOut->u_width; Params.m_outputSize.m_height = pPlaneOut->u_height; Params.m_bOutputStripe = M4OSA_FALSE; Params.m_outputOrientation = M4COMMON_kOrientationTopLeft; /** Media rendering: Black borders*/ if(mediaRendering == M4xVSS_kBlackBorders) { memset((void *)pPlaneOut[0].pac_data,Y_PLANE_BORDER_VALUE,(pPlaneOut[0].u_height*pPlaneOut[0].u_stride)); memset((void *)pPlaneOut[1].pac_data,U_PLANE_BORDER_VALUE,(pPlaneOut[1].u_height*pPlaneOut[1].u_stride)); memset((void *)pPlaneOut[2].pac_data,V_PLANE_BORDER_VALUE,(pPlaneOut[2].u_height*pPlaneOut[2].u_stride)); pImagePlanesTemp[0].u_width = pPlaneOut[0].u_width; pImagePlanesTemp[0].u_height = pPlaneOut[0].u_height; pImagePlanesTemp[0].u_stride = pPlaneOut[0].u_width; pImagePlanesTemp[0].u_topleft = 0; pImagePlanesTemp[0].pac_data = M4OSA_NULL; pImagePlanesTemp[1].u_width = pPlaneOut[1].u_width; pImagePlanesTemp[1].u_height = pPlaneOut[1].u_height; pImagePlanesTemp[1].u_stride = pPlaneOut[1].u_width; pImagePlanesTemp[1].u_topleft = 0; pImagePlanesTemp[1].pac_data = M4OSA_NULL; pImagePlanesTemp[2].u_width = pPlaneOut[2].u_width; pImagePlanesTemp[2].u_height = pPlaneOut[2].u_height; pImagePlanesTemp[2].u_stride = pPlaneOut[2].u_width; pImagePlanesTemp[2].u_topleft = 0; pImagePlanesTemp[2].pac_data = M4OSA_NULL; /* Allocates plan in local image plane structure */ pImagePlanesTemp[0].pac_data = (M4OSA_UInt8*)M4OSA_32bitAlignedMalloc(pImagePlanesTemp[0].u_width * pImagePlanesTemp[0].u_height, M4VS, (M4OSA_Char*)"applyRenderingMode: temporary plane bufferY") ; if(pImagePlanesTemp[0].pac_data == M4OSA_NULL) { M4OSA_TRACE1_0("Error alloc in applyRenderingMode"); return M4ERR_ALLOC; } pImagePlanesTemp[1].pac_data = (M4OSA_UInt8*)M4OSA_32bitAlignedMalloc(pImagePlanesTemp[1].u_width * pImagePlanesTemp[1].u_height, M4VS, (M4OSA_Char*)"applyRenderingMode: temporary plane bufferU") ; if(pImagePlanesTemp[1].pac_data == M4OSA_NULL) { M4OSA_TRACE1_0("Error alloc in applyRenderingMode"); return M4ERR_ALLOC; } pImagePlanesTemp[2].pac_data = (M4OSA_UInt8*)M4OSA_32bitAlignedMalloc(pImagePlanesTemp[2].u_width * pImagePlanesTemp[2].u_height, M4VS, (M4OSA_Char*)"applyRenderingMode: temporary plane bufferV") ; if(pImagePlanesTemp[2].pac_data == M4OSA_NULL) { M4OSA_TRACE1_0("Error alloc in applyRenderingMode"); return M4ERR_ALLOC; } pInPlaneY = pImagePlanesTemp[0].pac_data ; pInPlaneU = pImagePlanesTemp[1].pac_data ; pInPlaneV = pImagePlanesTemp[2].pac_data ; memset((void *)pImagePlanesTemp[0].pac_data,Y_PLANE_BORDER_VALUE,(pImagePlanesTemp[0].u_height*pImagePlanesTemp[0].u_stride)); memset((void *)pImagePlanesTemp[1].pac_data,U_PLANE_BORDER_VALUE,(pImagePlanesTemp[1].u_height*pImagePlanesTemp[1].u_stride)); memset((void *)pImagePlanesTemp[2].pac_data,V_PLANE_BORDER_VALUE,(pImagePlanesTemp[2].u_height*pImagePlanesTemp[2].u_stride)); 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) { /*it is height so black borders will be on the top and on the bottom side*/ Params.m_outputSize.m_width = pPlaneOut->u_width; Params.m_outputSize.m_height = (M4OSA_UInt32)((pPlaneIn->u_height * pPlaneOut->u_width) /pPlaneIn->u_width); /*number of lines at the top*/ pImagePlanesTemp[0].u_topleft = (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[0].u_height-Params.m_outputSize.m_height)>>1))*pImagePlanesTemp[0].u_stride; pImagePlanesTemp[0].u_height = Params.m_outputSize.m_height; pImagePlanesTemp[1].u_topleft = (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[1].u_height-(Params.m_outputSize.m_height>>1)))>>1)*pImagePlanesTemp[1].u_stride; pImagePlanesTemp[1].u_height = Params.m_outputSize.m_height>>1; pImagePlanesTemp[2].u_topleft = (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[2].u_height-(Params.m_outputSize.m_height>>1)))>>1)*pImagePlanesTemp[2].u_stride; pImagePlanesTemp[2].u_height = Params.m_outputSize.m_height>>1; } else { /*it is width so black borders will be on the left and right side*/ Params.m_outputSize.m_height = pPlaneOut->u_height; Params.m_outputSize.m_width = (M4OSA_UInt32)((pPlaneIn->u_width * pPlaneOut->u_height) /pPlaneIn->u_height); pImagePlanesTemp[0].u_topleft = (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[0].u_width-Params.m_outputSize.m_width)>>1)); pImagePlanesTemp[0].u_width = Params.m_outputSize.m_width; pImagePlanesTemp[1].u_topleft = (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[1].u_width-(Params.m_outputSize.m_width>>1)))>>1); pImagePlanesTemp[1].u_width = Params.m_outputSize.m_width>>1; pImagePlanesTemp[2].u_topleft = (M4xVSS_ABS((M4OSA_Int32)(pImagePlanesTemp[2].u_width-(Params.m_outputSize.m_width>>1)))>>1); pImagePlanesTemp[2].u_width = Params.m_outputSize.m_width>>1; } /*Width and height have to be even*/ Params.m_outputSize.m_width = (Params.m_outputSize.m_width>>1)<<1; Params.m_outputSize.m_height = (Params.m_outputSize.m_height>>1)<<1; Params.m_inputSize.m_width = (Params.m_inputSize.m_width>>1)<<1; Params.m_inputSize.m_height = (Params.m_inputSize.m_height>>1)<<1; pImagePlanesTemp[0].u_width = (pImagePlanesTemp[0].u_width>>1)<<1; pImagePlanesTemp[1].u_width = (pImagePlanesTemp[1].u_width>>1)<<1; pImagePlanesTemp[2].u_width = (pImagePlanesTemp[2].u_width>>1)<<1; pImagePlanesTemp[0].u_height = (pImagePlanesTemp[0].u_height>>1)<<1; pImagePlanesTemp[1].u_height = (pImagePlanesTemp[1].u_height>>1)<<1; pImagePlanesTemp[2].u_height = (pImagePlanesTemp[2].u_height>>1)<<1; /*Check that values are coherent*/ if(Params.m_inputSize.m_height == Params.m_outputSize.m_height) { Params.m_inputSize.m_width = Params.m_outputSize.m_width; } else if(Params.m_inputSize.m_width == Params.m_outputSize.m_width) { Params.m_inputSize.m_height = Params.m_outputSize.m_height; } pPlaneTemp = pImagePlanesTemp; } /** Media rendering: Cropping*/ if(mediaRendering == M4xVSS_kCropping) { Params.m_outputSize.m_height = pPlaneOut->u_height; Params.m_outputSize.m_width = pPlaneOut->u_width; if((Params.m_outputSize.m_height * Params.m_inputSize.m_width) /Params.m_outputSize.m_width>1)<<1; Params.m_inputCoord.m_y = (M4OSA_Int32)((M4OSA_Int32)((pPlaneIn->u_height - Params.m_inputSize.m_height))>>1); } else { /*width will be cropped*/ Params.m_inputSize.m_width = (M4OSA_UInt32)((Params.m_outputSize.m_width * Params.m_inputSize.m_height) /Params.m_outputSize.m_height); Params.m_inputSize.m_width = (Params.m_inputSize.m_width>>1)<<1; Params.m_inputCoord.m_x = (M4OSA_Int32)((M4OSA_Int32)((pPlaneIn->u_width - Params.m_inputSize.m_width))>>1); } pPlaneTemp = pPlaneOut; } /** * Call AIR functions */ err = M4AIR_create(&m_air_context, M4AIR_kYUV420P); if(err != M4NO_ERROR) { M4OSA_TRACE1_1("applyRenderingMode: Error when initializing AIR: 0x%x", err); for(i=0; i<3; i++) { if(pImagePlanesTemp[i].pac_data != M4OSA_NULL) { free(pImagePlanesTemp[i].pac_data); pImagePlanesTemp[i].pac_data = M4OSA_NULL; } } return err; } err = M4AIR_configure(m_air_context, &Params); if(err != M4NO_ERROR) { M4OSA_TRACE1_1("applyRenderingMode: Error when configuring AIR: 0x%x", err); M4AIR_cleanUp(m_air_context); for(i=0; i<3; i++) { if(pImagePlanesTemp[i].pac_data != M4OSA_NULL) { free(pImagePlanesTemp[i].pac_data); pImagePlanesTemp[i].pac_data = M4OSA_NULL; } } return err; } err = M4AIR_get(m_air_context, pPlaneIn, pPlaneTemp); if(err != M4NO_ERROR) { M4OSA_TRACE1_1("applyRenderingMode: Error when getting AIR plane: 0x%x", err); M4AIR_cleanUp(m_air_context); for(i=0; i<3; i++) { if(pImagePlanesTemp[i].pac_data != M4OSA_NULL) { free(pImagePlanesTemp[i].pac_data); pImagePlanesTemp[i].pac_data = M4OSA_NULL; } } return err; } if(mediaRendering == M4xVSS_kBlackBorders) { for(i=0; im_inputFormat = inputFormat; pC->m_state = M4AIR_kCreated; /* Return the context to the caller */ *pContext = pC ; return M4NO_ERROR ; M4AIR_create_cleanup: /* Error management : we destroy the context if needed */ if(M4OSA_NULL != pC) { free(pC) ; } *pContext = M4OSA_NULL ; return err ; } /** ****************************************************************************** * M4OSA_ERR M4AIR_cleanUp(M4OSA_Context pContext) * @author Arnaud Collard * @brief This function destroys an instance of the AIR component * @param pContext: (IN) Context identifying the instance to destroy * @return M4NO_ERROR: there is no error * @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only). * @return M4ERR_STATE: Internal state is incompatible with this function call. ****************************************************************************** */ M4OSA_ERR M4AIR_cleanUp(M4OSA_Context pContext) { M4AIR_InternalContext* pC = (M4AIR_InternalContext*)pContext ; M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pContext) ; /**< Check state */ if((M4AIR_kCreated != pC->m_state)&&(M4AIR_kConfigured != pC->m_state)) { return M4ERR_STATE; } free(pC) ; return M4NO_ERROR ; } /** ****************************************************************************** * M4OSA_ERR M4AIR_configure(M4OSA_Context pContext, M4AIR_Params* pParams) * @brief This function will configure the AIR. * @note It will set the input and output coordinates and sizes, * and indicates if we will proceed in stripe or not. * In case a M4AIR_get in stripe mode was on going, it will cancel this previous processing * and reset the get process. * @param pContext: (IN) Context identifying the instance * @param pParams->m_bOutputStripe:(IN) Stripe mode. * @param pParams->m_inputCoord: (IN) X,Y coordinates of the first valid pixel in input. * @param pParams->m_inputSize: (IN) input ROI size. * @param pParams->m_outputSize: (IN) output size. * @return M4NO_ERROR: there is no error * @return M4ERR_ALLOC: No more memory space to add a new effect. * @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only). * @return M4ERR_AIR_FORMAT_NOT_SUPPORTED: the requested input format is not supported. ****************************************************************************** */ M4OSA_ERR M4AIR_configure(M4OSA_Context pContext, M4AIR_Params* pParams) { M4AIR_InternalContext* pC = (M4AIR_InternalContext*)pContext ; M4OSA_UInt32 i,u32_width_in, u32_width_out, u32_height_in, u32_height_out; M4OSA_UInt32 nb_planes; M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pContext) ; if(M4AIR_kYUV420AP == pC->m_inputFormat) { nb_planes = 4; } else { nb_planes = 3; } /**< Check state */ if((M4AIR_kCreated != pC->m_state)&&(M4AIR_kConfigured != pC->m_state)) { return M4ERR_STATE; } /** Save parameters */ pC->m_params = *pParams; /* Check for the input&output width and height are even */ if( ((pC->m_params.m_inputSize.m_height)&0x1) || ((pC->m_params.m_inputSize.m_height)&0x1)) { return M4ERR_AIR_ILLEGAL_FRAME_SIZE; } if( ((pC->m_params.m_inputSize.m_width)&0x1) || ((pC->m_params.m_inputSize.m_width)&0x1)) { return M4ERR_AIR_ILLEGAL_FRAME_SIZE; } if(((pC->m_params.m_inputSize.m_width) == (pC->m_params.m_outputSize.m_width)) &&((pC->m_params.m_inputSize.m_height) == (pC->m_params.m_outputSize.m_height))) { /**< No resize in this case, we will just copy input in output */ pC->m_bOnlyCopy = M4OSA_TRUE; } else { pC->m_bOnlyCopy = M4OSA_FALSE; /**< Initialize internal variables used for resize filter */ for(i=0;im_params.m_inputSize.m_width:(pC->m_params.m_inputSize.m_width+1)>>1; u32_height_in = ((i==0)||(i==3))?pC->m_params.m_inputSize.m_height:(pC->m_params.m_inputSize.m_height+1)>>1; u32_width_out = ((i==0)||(i==3))?pC->m_params.m_outputSize.m_width:(pC->m_params.m_outputSize.m_width+1)>>1; u32_height_out = ((i==0)||(i==3))?pC->m_params.m_outputSize.m_height:(pC->m_params.m_outputSize.m_height+1)>>1; /* Compute horizontal ratio between src and destination width.*/ if (u32_width_out >= u32_width_in) { pC->u32_x_inc[i] = ((u32_width_in-1) * 0x10000) / (u32_width_out-1); } else { pC->u32_x_inc[i] = (u32_width_in * 0x10000) / (u32_width_out); } /* Compute vertical ratio between src and destination height.*/ if (u32_height_out >= u32_height_in) { pC->u32_y_inc[i] = ((u32_height_in - 1) * 0x10000) / (u32_height_out-1); } else { pC->u32_y_inc[i] = (u32_height_in * 0x10000) / (u32_height_out); } /* Calculate initial accumulator value : u32_y_accum_start. u32_y_accum_start is coded on 15 bits, and represents a value between 0 and 0.5 */ if (pC->u32_y_inc[i] >= 0x10000) { /* Keep the fractionnal part, assimung that integer part is coded on the 16 high bits and the fractionnal on the 15 low bits */ pC->u32_y_accum_start[i] = pC->u32_y_inc[i] & 0xffff; if (!pC->u32_y_accum_start[i]) { pC->u32_y_accum_start[i] = 0x10000; } pC->u32_y_accum_start[i] >>= 1; } else { pC->u32_y_accum_start[i] = 0; } /**< Take into account that Y coordinate can be odd in this case we have to put a 0.5 offset for U and V plane as there a 2 times sub-sampled vs Y*/ if((pC->m_params.m_inputCoord.m_y&0x1)&&((i==1)||(i==2))) { pC->u32_y_accum_start[i] += 0x8000; } /* Calculate initial accumulator value : u32_x_accum_start. u32_x_accum_start is coded on 15 bits, and represents a value between 0 and 0.5 */ if (pC->u32_x_inc[i] >= 0x10000) { pC->u32_x_accum_start[i] = pC->u32_x_inc[i] & 0xffff; if (!pC->u32_x_accum_start[i]) { pC->u32_x_accum_start[i] = 0x10000; } pC->u32_x_accum_start[i] >>= 1; } else { pC->u32_x_accum_start[i] = 0; } /**< Take into account that X coordinate can be odd in this case we have to put a 0.5 offset for U and V plane as there a 2 times sub-sampled vs Y*/ if((pC->m_params.m_inputCoord.m_x&0x1)&&((i==1)||(i==2))) { pC->u32_x_accum_start[i] += 0x8000; } } } /**< Reset variable used for stripe mode */ pC->m_procRows = 0; /**< Initialize var for X/Y processing order according to orientation */ pC->m_bFlipX = M4OSA_FALSE; pC->m_bFlipY = M4OSA_FALSE; pC->m_bRevertXY = M4OSA_FALSE; switch(pParams->m_outputOrientation) { case M4COMMON_kOrientationTopLeft: break; case M4COMMON_kOrientationTopRight: pC->m_bFlipX = M4OSA_TRUE; break; case M4COMMON_kOrientationBottomRight: pC->m_bFlipX = M4OSA_TRUE; pC->m_bFlipY = M4OSA_TRUE; break; case M4COMMON_kOrientationBottomLeft: pC->m_bFlipY = M4OSA_TRUE; break; case M4COMMON_kOrientationLeftTop: pC->m_bRevertXY = M4OSA_TRUE; break; case M4COMMON_kOrientationRightTop: pC->m_bRevertXY = M4OSA_TRUE; pC->m_bFlipY = M4OSA_TRUE; break; case M4COMMON_kOrientationRightBottom: pC->m_bRevertXY = M4OSA_TRUE; pC->m_bFlipX = M4OSA_TRUE; pC->m_bFlipY = M4OSA_TRUE; break; case M4COMMON_kOrientationLeftBottom: pC->m_bRevertXY = M4OSA_TRUE; pC->m_bFlipX = M4OSA_TRUE; break; default: return M4ERR_PARAMETER; } /**< Update state */ pC->m_state = M4AIR_kConfigured; return M4NO_ERROR ; } /** ****************************************************************************** * M4OSA_ERR M4AIR_get(M4OSA_Context pContext, M4VIFI_ImagePlane* pIn, M4VIFI_ImagePlane* pOut) * @brief This function will provide the requested resized area of interest according to settings * provided in M4AIR_configure. * @note In case the input format type is JPEG, input plane(s) * in pIn is not used. In normal mode, dimension specified in output plane(s) structure must be the * same than the one specified in M4AIR_configure. In stripe mode, only the width will be the same, * height will be taken as the stripe height (typically 16). * In normal mode, this function is call once to get the full output picture. In stripe mode, it is called * for each stripe till the whole picture has been retrieved,and the position of the output stripe in the output picture * is internally incremented at each step. * Any call to M4AIR_configure during stripe process will reset this one to the beginning of the output picture. * @param pContext: (IN) Context identifying the instance * @param pIn: (IN) Plane structure containing input Plane(s). * @param pOut: (IN/OUT) Plane structure containing output Plane(s). * @return M4NO_ERROR: there is no error * @return M4ERR_ALLOC: No more memory space to add a new effect. * @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only). ****************************************************************************** */ M4OSA_ERR M4AIR_get(M4OSA_Context pContext, M4VIFI_ImagePlane* pIn, M4VIFI_ImagePlane* pOut) { M4AIR_InternalContext* pC = (M4AIR_InternalContext*)pContext ; M4OSA_UInt32 i,j,k,u32_x_frac,u32_y_frac,u32_x_accum,u32_y_accum,u32_shift; M4OSA_UInt8 *pu8_data_in, *pu8_data_in_org, *pu8_data_in_tmp, *pu8_data_out; M4OSA_UInt8 *pu8_src_top; M4OSA_UInt8 *pu8_src_bottom; M4OSA_UInt32 u32_temp_value; M4OSA_Int32 i32_tmp_offset; M4OSA_UInt32 nb_planes; M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pContext) ; /**< Check state */ if(M4AIR_kConfigured != pC->m_state) { return M4ERR_STATE; } if(M4AIR_kYUV420AP == pC->m_inputFormat) { nb_planes = 4; } else { nb_planes = 3; } /**< Loop on each Plane */ for(i=0;im_params.m_bOutputStripe)||((M4OSA_TRUE == pC->m_params.m_bOutputStripe)&&(0 == pC->m_procRows))) { /**< For input, take care about ROI */ pu8_data_in = pIn[i].pac_data + pIn[i].u_topleft + (pC->m_params.m_inputCoord.m_x>>u32_shift) + (pC->m_params.m_inputCoord.m_y >> u32_shift) * pIn[i].u_stride; /** Go at end of line/column in case X/Y scanning is flipped */ if(M4OSA_TRUE == pC->m_bFlipX) { pu8_data_in += ((pC->m_params.m_inputSize.m_width)>>u32_shift) -1 ; } if(M4OSA_TRUE == pC->m_bFlipY) { pu8_data_in += ((pC->m_params.m_inputSize.m_height>>u32_shift) -1) * pIn[i].u_stride; } /**< Initialize accumulators in case we are using it (bilinear interpolation) */ if( M4OSA_FALSE == pC->m_bOnlyCopy) { pC->u32_x_accum[i] = pC->u32_x_accum_start[i]; pC->u32_y_accum[i] = pC->u32_y_accum_start[i]; } } else { /**< In case of stripe mode for other than first stripe, we need to recover input pointer from internal context */ pu8_data_in = pC->pu8_data_in[i]; } /**< In every mode, output data are at the beginning of the output plane */ pu8_data_out = pOut[i].pac_data + pOut[i].u_topleft; /**< Initialize input offset applied after each pixel */ if(M4OSA_FALSE == pC->m_bFlipY) { i32_tmp_offset = pIn[i].u_stride; } else { i32_tmp_offset = -pIn[i].u_stride; } /**< In this case, no bilinear interpolation is needed as input and output dimensions are the same */ if( M4OSA_TRUE == pC->m_bOnlyCopy) { /**< No +-90° rotation */ if(M4OSA_FALSE == pC->m_bRevertXY) { /**< No flip on X abscissa */ if(M4OSA_FALSE == pC->m_bFlipX) { M4OSA_UInt32 loc_height = pOut[i].u_height; M4OSA_UInt32 loc_width = pOut[i].u_width; M4OSA_UInt32 loc_stride = pIn[i].u_stride; /**< Loop on each row */ for (j=0; jm_bFlipY) { pu8_data_in += loc_stride; } else { pu8_data_in -= loc_stride; } } } else { /**< Loop on each row */ for(j=0;jm_bFlipX) { pu8_data_in ++; } else { pu8_data_in --; } } } } /**< Bilinear interpolation */ else { if(3 != i) /**< other than alpha plane */ { /**No +-90° rotation */ if(M4OSA_FALSE == pC->m_bRevertXY) { /**< Loop on each row */ for(j=0;ju32_y_accum[i]>>12)&15; /* Reinit horizontal weight factor */ u32_x_accum = pC->u32_x_accum_start[i]; if(M4OSA_TRUE == pC->m_bFlipX) { /**< Loop on each output pixel in a row */ for(k=0;k> 12)&15; /* Fraction of Horizontal weight factor */ pu8_src_top = (pu8_data_in - (u32_x_accum >> 16)) -1 ; pu8_src_bottom = pu8_src_top + i32_tmp_offset; /* Weighted combination */ u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[1]*(16-u32_x_frac) + pu8_src_top[0]*u32_x_frac)*(16-u32_y_frac) + (pu8_src_bottom[1]*(16-u32_x_frac) + pu8_src_bottom[0]*u32_x_frac)*u32_y_frac )>>8); *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; /* Update horizontal accumulator */ u32_x_accum += pC->u32_x_inc[i]; } } else { /**< Loop on each output pixel in a row */ for(k=0;k> 12)&15; /* Fraction of Horizontal weight factor */ pu8_src_top = pu8_data_in + (u32_x_accum >> 16); pu8_src_bottom = pu8_src_top + i32_tmp_offset; /* Weighted combination */ u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[0]*(16-u32_x_frac) + pu8_src_top[1]*u32_x_frac)*(16-u32_y_frac) + (pu8_src_bottom[0]*(16-u32_x_frac) + pu8_src_bottom[1]*u32_x_frac)*u32_y_frac )>>8); *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; /* Update horizontal accumulator */ u32_x_accum += pC->u32_x_inc[i]; } } pu8_data_out += pOut[i].u_stride - pOut[i].u_width; /* Update vertical accumulator */ pC->u32_y_accum[i] += pC->u32_y_inc[i]; if (pC->u32_y_accum[i]>>16) { pu8_data_in = pu8_data_in + (pC->u32_y_accum[i] >> 16) * i32_tmp_offset; pC->u32_y_accum[i] &= 0xffff; } } } /** +-90° rotation */ else { pu8_data_in_org = pu8_data_in; /**< Loop on each output row */ for(j=0;ju32_x_accum[i]>>12)&15; /* Reinit accumulator */ u32_y_accum = pC->u32_y_accum_start[i]; if(M4OSA_TRUE == pC->m_bFlipX) { /**< Loop on each output pixel in a row */ for(k=0;k> 12)&15; /* Vertical weight factor */ pu8_src_top = (pu8_data_in - (pC->u32_x_accum[i] >> 16)) - 1; pu8_src_bottom = pu8_src_top + i32_tmp_offset; /* Weighted combination */ u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[1]*(16-u32_x_frac) + pu8_src_top[0]*u32_x_frac)*(16-u32_y_frac) + (pu8_src_bottom[1]*(16-u32_x_frac) + pu8_src_bottom[0]*u32_x_frac)*u32_y_frac )>>8); *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; /* Update vertical accumulator */ u32_y_accum += pC->u32_y_inc[i]; if (u32_y_accum>>16) { pu8_data_in = pu8_data_in + (u32_y_accum >> 16) * i32_tmp_offset; u32_y_accum &= 0xffff; } } } else { /**< Loop on each output pixel in a row */ for(k=0;k> 12)&15; /* Vertical weight factor */ pu8_src_top = pu8_data_in + (pC->u32_x_accum[i] >> 16); pu8_src_bottom = pu8_src_top + i32_tmp_offset; /* Weighted combination */ u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[0]*(16-u32_x_frac) + pu8_src_top[1]*u32_x_frac)*(16-u32_y_frac) + (pu8_src_bottom[0]*(16-u32_x_frac) + pu8_src_bottom[1]*u32_x_frac)*u32_y_frac )>>8); *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; /* Update vertical accumulator */ u32_y_accum += pC->u32_y_inc[i]; if (u32_y_accum>>16) { pu8_data_in = pu8_data_in + (u32_y_accum >> 16) * i32_tmp_offset; u32_y_accum &= 0xffff; } } } pu8_data_out += pOut[i].u_stride - pOut[i].u_width; /* Update horizontal accumulator */ pC->u32_x_accum[i] += pC->u32_x_inc[i]; pu8_data_in = pu8_data_in_org; } } }/** 3 != i */ else { /**No +-90° rotation */ if(M4OSA_FALSE == pC->m_bRevertXY) { /**< Loop on each row */ for(j=0;ju32_y_accum[i]>>12)&15; /* Reinit horizontal weight factor */ u32_x_accum = pC->u32_x_accum_start[i]; if(M4OSA_TRUE == pC->m_bFlipX) { /**< Loop on each output pixel in a row */ for(k=0;k> 12)&15; /* Fraction of Horizontal weight factor */ pu8_src_top = (pu8_data_in - (u32_x_accum >> 16)) -1 ; pu8_src_bottom = pu8_src_top + i32_tmp_offset; /* Weighted combination */ u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[1]*(16-u32_x_frac) + pu8_src_top[0]*u32_x_frac)*(16-u32_y_frac) + (pu8_src_bottom[1]*(16-u32_x_frac) + pu8_src_bottom[0]*u32_x_frac)*u32_y_frac )>>8); u32_temp_value= (u32_temp_value >> 7)*0xff; *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; /* Update horizontal accumulator */ u32_x_accum += pC->u32_x_inc[i]; } } else { /**< Loop on each output pixel in a row */ for(k=0;k> 12)&15; /* Fraction of Horizontal weight factor */ pu8_src_top = pu8_data_in + (u32_x_accum >> 16); pu8_src_bottom = pu8_src_top + i32_tmp_offset; /* Weighted combination */ u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[0]*(16-u32_x_frac) + pu8_src_top[1]*u32_x_frac)*(16-u32_y_frac) + (pu8_src_bottom[0]*(16-u32_x_frac) + pu8_src_bottom[1]*u32_x_frac)*u32_y_frac )>>8); u32_temp_value= (u32_temp_value >> 7)*0xff; *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; /* Update horizontal accumulator */ u32_x_accum += pC->u32_x_inc[i]; } } pu8_data_out += pOut[i].u_stride - pOut[i].u_width; /* Update vertical accumulator */ pC->u32_y_accum[i] += pC->u32_y_inc[i]; if (pC->u32_y_accum[i]>>16) { pu8_data_in = pu8_data_in + (pC->u32_y_accum[i] >> 16) * i32_tmp_offset; pC->u32_y_accum[i] &= 0xffff; } } } /**< M4OSA_FALSE == pC->m_bRevertXY */ /** +-90° rotation */ else { pu8_data_in_org = pu8_data_in; /**< Loop on each output row */ for(j=0;ju32_x_accum[i]>>12)&15; /* Reinit accumulator */ u32_y_accum = pC->u32_y_accum_start[i]; if(M4OSA_TRUE == pC->m_bFlipX) { /**< Loop on each output pixel in a row */ for(k=0;k> 12)&15; /* Vertical weight factor */ pu8_src_top = (pu8_data_in - (pC->u32_x_accum[i] >> 16)) - 1; pu8_src_bottom = pu8_src_top + i32_tmp_offset; /* Weighted combination */ u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[1]*(16-u32_x_frac) + pu8_src_top[0]*u32_x_frac)*(16-u32_y_frac) + (pu8_src_bottom[1]*(16-u32_x_frac) + pu8_src_bottom[0]*u32_x_frac)*u32_y_frac )>>8); u32_temp_value= (u32_temp_value >> 7)*0xff; *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; /* Update vertical accumulator */ u32_y_accum += pC->u32_y_inc[i]; if (u32_y_accum>>16) { pu8_data_in = pu8_data_in + (u32_y_accum >> 16) * i32_tmp_offset; u32_y_accum &= 0xffff; } } } else { /**< Loop on each output pixel in a row */ for(k=0;k> 12)&15; /* Vertical weight factor */ pu8_src_top = pu8_data_in + (pC->u32_x_accum[i] >> 16); pu8_src_bottom = pu8_src_top + i32_tmp_offset; /* Weighted combination */ u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[0]*(16-u32_x_frac) + pu8_src_top[1]*u32_x_frac)*(16-u32_y_frac) + (pu8_src_bottom[0]*(16-u32_x_frac) + pu8_src_bottom[1]*u32_x_frac)*u32_y_frac )>>8); u32_temp_value= (u32_temp_value >> 7)*0xff; *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; /* Update vertical accumulator */ u32_y_accum += pC->u32_y_inc[i]; if (u32_y_accum>>16) { pu8_data_in = pu8_data_in + (u32_y_accum >> 16) * i32_tmp_offset; u32_y_accum &= 0xffff; } } } pu8_data_out += pOut[i].u_stride - pOut[i].u_width; /* Update horizontal accumulator */ pC->u32_x_accum[i] += pC->u32_x_inc[i]; pu8_data_in = pu8_data_in_org; } } /**< M4OSA_TRUE == pC->m_bRevertXY */ }/** 3 == i */ } /**< In case of stripe mode, save current input pointer */ if(M4OSA_TRUE == pC->m_params.m_bOutputStripe) { pC->pu8_data_in[i] = pu8_data_in; } } /**< Update number of processed rows, reset it if we have finished with the whole processing */ pC->m_procRows += pOut[0].u_height; if(M4OSA_FALSE == pC->m_bRevertXY) { if(pC->m_params.m_outputSize.m_height <= pC->m_procRows) pC->m_procRows = 0; } else { if(pC->m_params.m_outputSize.m_width <= pC->m_procRows) pC->m_procRows = 0; } return M4NO_ERROR ; } /*+ Handle the image files here */ /** ****************************************************************************** * M4OSA_ERR LvGetImageThumbNail(M4OSA_UChar *fileName, M4OSA_Void **pBuffer) * @brief This function gives YUV420 buffer of a given image file (in argb888 format) * @Note: The caller of the function is responsible to free the yuv buffer allocated * @param fileName: (IN) Path to the filename of the image argb data * @param height: (IN) Height of the image * @param width: (OUT) pBuffer pointer to the address where the yuv data address needs to be returned. * @return M4NO_ERROR: there is no error * @return M4ERR_ALLOC: No more memory space to add a new effect. * @return M4ERR_FILE_NOT_FOUND: if the file passed does not exists. ****************************************************************************** */ M4OSA_ERR LvGetImageThumbNail(const char *fileName, M4OSA_UInt32 height, M4OSA_UInt32 width, M4OSA_Void **pBuffer) { M4VIFI_ImagePlane rgbPlane, *yuvPlane; M4OSA_UInt32 frameSize_argb = (width * height * 4); // argb data M4OSA_Context lImageFileFp = M4OSA_NULL; M4OSA_ERR err = M4NO_ERROR; M4OSA_UInt8 *pTmpData = (M4OSA_UInt8*) M4OSA_32bitAlignedMalloc(frameSize_argb, M4VS, (M4OSA_Char*)"Image argb data"); if(pTmpData == M4OSA_NULL) { ALOGE("Failed to allocate memory for Image clip"); return M4ERR_ALLOC; } /** Read the argb data from the passed file. */ M4OSA_ERR lerr = M4OSA_fileReadOpen(&lImageFileFp, (M4OSA_Void *) fileName, M4OSA_kFileRead); if((lerr != M4NO_ERROR) || (lImageFileFp == M4OSA_NULL)) { ALOGE("LVPreviewController: Can not open the file "); free(pTmpData); return M4ERR_FILE_NOT_FOUND; } lerr = M4OSA_fileReadData(lImageFileFp, (M4OSA_MemAddr8)pTmpData, &frameSize_argb); if(lerr != M4NO_ERROR) { ALOGE("LVPreviewController: can not read the data "); M4OSA_fileReadClose(lImageFileFp); free(pTmpData); return lerr; } M4OSA_fileReadClose(lImageFileFp); M4OSA_UInt32 frameSize = (width * height * 3); //Size of YUV420 data. rgbPlane.pac_data = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(frameSize, M4VS, (M4OSA_Char*)"Image clip RGB888 data"); if(rgbPlane.pac_data == M4OSA_NULL) { ALOGE("Failed to allocate memory for Image clip"); free(pTmpData); return M4ERR_ALLOC; } /** Remove the alpha channel */ for (M4OSA_UInt32 i=0, j = 0; i < frameSize_argb; i++) { if ((i % 4) == 0) continue; rgbPlane.pac_data[j] = pTmpData[i]; j++; } free(pTmpData); #ifdef FILE_DUMP FILE *fp = fopen("/sdcard/Input/test_rgb.raw", "wb"); if(fp == NULL) ALOGE("Errors file can not be created"); else { fwrite(rgbPlane.pac_data, frameSize, 1, fp); fclose(fp); } #endif rgbPlane.u_height = height; rgbPlane.u_width = width; rgbPlane.u_stride = width*3; rgbPlane.u_topleft = 0; yuvPlane = (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc(3*sizeof(M4VIFI_ImagePlane), M4VS, (M4OSA_Char*)"M4xVSS_internalConvertRGBtoYUV: Output plane YUV"); yuvPlane[0].u_height = height; yuvPlane[0].u_width = width; yuvPlane[0].u_stride = width; yuvPlane[0].u_topleft = 0; yuvPlane[0].pac_data = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(yuvPlane[0].u_height * yuvPlane[0].u_width * 1.5, M4VS, (M4OSA_Char*)"imageClip YUV data"); yuvPlane[1].u_height = yuvPlane[0].u_height >>1; yuvPlane[1].u_width = yuvPlane[0].u_width >> 1; yuvPlane[1].u_stride = yuvPlane[1].u_width; yuvPlane[1].u_topleft = 0; yuvPlane[1].pac_data = (M4VIFI_UInt8*)(yuvPlane[0].pac_data + yuvPlane[0].u_height * yuvPlane[0].u_width); yuvPlane[2].u_height = yuvPlane[0].u_height >>1; yuvPlane[2].u_width = yuvPlane[0].u_width >> 1; yuvPlane[2].u_stride = yuvPlane[2].u_width; yuvPlane[2].u_topleft = 0; yuvPlane[2].pac_data = (M4VIFI_UInt8*)(yuvPlane[1].pac_data + yuvPlane[1].u_height * yuvPlane[1].u_width); err = M4VIFI_RGB888toYUV420(M4OSA_NULL, &rgbPlane, yuvPlane); //err = M4VIFI_BGR888toYUV420(M4OSA_NULL, &rgbPlane, yuvPlane); if(err != M4NO_ERROR) { ALOGE("error when converting from RGB to YUV: 0x%x\n", (unsigned int)err); } free(rgbPlane.pac_data); //ALOGE("RGB to YUV done"); #ifdef FILE_DUMP FILE *fp1 = fopen("/sdcard/Input/test_yuv.raw", "wb"); if(fp1 == NULL) ALOGE("Errors file can not be created"); else { fwrite(yuvPlane[0].pac_data, yuvPlane[0].u_height * yuvPlane[0].u_width * 1.5, 1, fp1); fclose(fp1); } #endif *pBuffer = yuvPlane[0].pac_data; free(yuvPlane); return M4NO_ERROR; } M4OSA_Void prepareYUV420ImagePlane(M4VIFI_ImagePlane *plane, M4OSA_UInt32 width, M4OSA_UInt32 height, M4VIFI_UInt8 *buffer, M4OSA_UInt32 reportedWidth, M4OSA_UInt32 reportedHeight) { //Y plane plane[0].u_width = width; plane[0].u_height = height; plane[0].u_stride = reportedWidth; plane[0].u_topleft = 0; plane[0].pac_data = buffer; // U plane plane[1].u_width = width/2; plane[1].u_height = height/2; plane[1].u_stride = reportedWidth >> 1; plane[1].u_topleft = 0; plane[1].pac_data = buffer+(reportedWidth*reportedHeight); // V Plane plane[2].u_width = width/2; plane[2].u_height = height/2; plane[2].u_stride = reportedWidth >> 1; plane[2].u_topleft = 0; plane[2].pac_data = plane[1].pac_data + ((reportedWidth/2)*(reportedHeight/2)); } M4OSA_Void prepareYV12ImagePlane(M4VIFI_ImagePlane *plane, M4OSA_UInt32 width, M4OSA_UInt32 height, M4OSA_UInt32 stride, M4VIFI_UInt8 *buffer) { //Y plane plane[0].u_width = width; plane[0].u_height = height; plane[0].u_stride = stride; plane[0].u_topleft = 0; plane[0].pac_data = buffer; // U plane plane[1].u_width = width/2; plane[1].u_height = height/2; plane[1].u_stride = android::PreviewRenderer::ALIGN(plane[0].u_stride/2, 16); plane[1].u_topleft = 0; plane[1].pac_data = (buffer + plane[0].u_height * plane[0].u_stride + (plane[0].u_height/2) * android::PreviewRenderer::ALIGN(( plane[0].u_stride / 2), 16)); // V Plane plane[2].u_width = width/2; plane[2].u_height = height/2; plane[2].u_stride = android::PreviewRenderer::ALIGN(plane[0].u_stride/2, 16); plane[2].u_topleft = 0; plane[2].pac_data = (buffer + plane[0].u_height * android::PreviewRenderer::ALIGN(plane[0].u_stride, 16)); } M4OSA_Void swapImagePlanes( M4VIFI_ImagePlane *planeIn, M4VIFI_ImagePlane *planeOut, M4VIFI_UInt8 *buffer1, M4VIFI_UInt8 *buffer2) { planeIn[0].u_height = planeOut[0].u_height; planeIn[0].u_width = planeOut[0].u_width; planeIn[0].u_stride = planeOut[0].u_stride; planeIn[0].u_topleft = planeOut[0].u_topleft; planeIn[0].pac_data = planeOut[0].pac_data; /** * U plane */ planeIn[1].u_width = planeOut[1].u_width; planeIn[1].u_height = planeOut[1].u_height; planeIn[1].u_stride = planeOut[1].u_stride; planeIn[1].u_topleft = planeOut[1].u_topleft; planeIn[1].pac_data = planeOut[1].pac_data; /** * V Plane */ planeIn[2].u_width = planeOut[2].u_width; planeIn[2].u_height = planeOut[2].u_height; planeIn[2].u_stride = planeOut[2].u_stride; planeIn[2].u_topleft = planeOut[2].u_topleft; planeIn[2].pac_data = planeOut[2].pac_data; if(planeOut[0].pac_data == (M4VIFI_UInt8*)buffer1) { planeOut[0].pac_data = (M4VIFI_UInt8*)buffer2; planeOut[1].pac_data = (M4VIFI_UInt8*)(buffer2 + planeOut[0].u_width*planeOut[0].u_height); planeOut[2].pac_data = (M4VIFI_UInt8*)(buffer2 + planeOut[0].u_width*planeOut[0].u_height + planeOut[1].u_width*planeOut[1].u_height); } else { planeOut[0].pac_data = (M4VIFI_UInt8*)buffer1; planeOut[1].pac_data = (M4VIFI_UInt8*)(buffer1 + planeOut[0].u_width*planeOut[0].u_height); planeOut[2].pac_data = (M4VIFI_UInt8*)(buffer1 + planeOut[0].u_width*planeOut[0].u_height + planeOut[1].u_width*planeOut[1].u_height); } } M4OSA_Void computePercentageDone( M4OSA_UInt32 ctsMs, M4OSA_UInt32 effectStartTimeMs, M4OSA_UInt32 effectDuration, M4OSA_Double *percentageDone) { M4OSA_Double videoEffectTime =0; // Compute how far from the beginning of the effect we are, in clip-base time. videoEffectTime = (M4OSA_Int32)(ctsMs+ 0.5) - effectStartTimeMs; // To calculate %, substract timeIncrement // because effect should finish on the last frame // which is from CTS = (eof-timeIncrement) till CTS = eof *percentageDone = videoEffectTime / ((M4OSA_Float)effectDuration); if(*percentageDone < 0.0) *percentageDone = 0.0; if(*percentageDone > 1.0) *percentageDone = 1.0; } M4OSA_Void computeProgressForVideoEffect( M4OSA_UInt32 ctsMs, M4OSA_UInt32 effectStartTimeMs, M4OSA_UInt32 effectDuration, M4VSS3GPP_ExternalProgress* extProgress) { M4OSA_Double percentageDone =0; computePercentageDone(ctsMs, effectStartTimeMs, effectDuration, &percentageDone); extProgress->uiProgress = (M4OSA_UInt32)( percentageDone * 1000 ); extProgress->uiOutputTime = (M4OSA_UInt32)(ctsMs + 0.5); extProgress->uiClipTime = extProgress->uiOutputTime; extProgress->bIsLast = M4OSA_FALSE; } M4OSA_ERR prepareFramingStructure( M4xVSS_FramingStruct* framingCtx, M4VSS3GPP_EffectSettings* effectsSettings, M4OSA_UInt32 index, M4VIFI_UInt8* overlayRGB, M4VIFI_UInt8* overlayYUV) { M4OSA_ERR err = M4NO_ERROR; // Force input RGB buffer to even size to avoid errors in YUV conversion framingCtx->FramingRgb = effectsSettings[index].xVSS.pFramingBuffer; framingCtx->FramingRgb->u_width = framingCtx->FramingRgb->u_width & ~1; framingCtx->FramingRgb->u_height = framingCtx->FramingRgb->u_height & ~1; framingCtx->FramingYuv = NULL; framingCtx->duration = effectsSettings[index].uiDuration; framingCtx->topleft_x = effectsSettings[index].xVSS.topleft_x; framingCtx->topleft_y = effectsSettings[index].xVSS.topleft_y; framingCtx->pCurrent = framingCtx; framingCtx->pNext = framingCtx; framingCtx->previousClipTime = -1; framingCtx->alphaBlendingStruct = (M4xVSS_internalEffectsAlphaBlending*)M4OSA_32bitAlignedMalloc( sizeof(M4xVSS_internalEffectsAlphaBlending), M4VS, (M4OSA_Char*)"alpha blending struct"); framingCtx->alphaBlendingStruct->m_fadeInTime = effectsSettings[index].xVSS.uialphaBlendingFadeInTime; framingCtx->alphaBlendingStruct->m_fadeOutTime = effectsSettings[index].xVSS.uialphaBlendingFadeOutTime; framingCtx->alphaBlendingStruct->m_end = effectsSettings[index].xVSS.uialphaBlendingEnd; framingCtx->alphaBlendingStruct->m_middle = effectsSettings[index].xVSS.uialphaBlendingMiddle; framingCtx->alphaBlendingStruct->m_start = effectsSettings[index].xVSS.uialphaBlendingStart; // If new Overlay buffer, convert from RGB to YUV if((overlayRGB != framingCtx->FramingRgb->pac_data) || (overlayYUV == NULL) ) { // If YUV buffer exists, delete it if(overlayYUV != NULL) { free(overlayYUV); overlayYUV = NULL; } if(effectsSettings[index].xVSS.rgbType == M4VSS3GPP_kRGB565) { // Input RGB565 plane is provided, // let's convert it to YUV420, and update framing structure err = M4xVSS_internalConvertRGBtoYUV(framingCtx); } else if(effectsSettings[index].xVSS.rgbType == M4VSS3GPP_kRGB888) { // Input RGB888 plane is provided, // let's convert it to YUV420, and update framing structure err = M4xVSS_internalConvertRGB888toYUV(framingCtx); } else { err = M4ERR_PARAMETER; } overlayYUV = framingCtx->FramingYuv[0].pac_data; overlayRGB = framingCtx->FramingRgb->pac_data; } else { ALOGV(" YUV buffer reuse"); framingCtx->FramingYuv = (M4VIFI_ImagePlane*)M4OSA_32bitAlignedMalloc( 3*sizeof(M4VIFI_ImagePlane), M4VS, (M4OSA_Char*)"YUV"); if(framingCtx->FramingYuv == M4OSA_NULL) { return M4ERR_ALLOC; } framingCtx->FramingYuv[0].u_width = framingCtx->FramingRgb->u_width; framingCtx->FramingYuv[0].u_height = framingCtx->FramingRgb->u_height; framingCtx->FramingYuv[0].u_topleft = 0; framingCtx->FramingYuv[0].u_stride = framingCtx->FramingRgb->u_width; framingCtx->FramingYuv[0].pac_data = (M4VIFI_UInt8*)overlayYUV; framingCtx->FramingYuv[1].u_width = (framingCtx->FramingRgb->u_width)>>1; framingCtx->FramingYuv[1].u_height = (framingCtx->FramingRgb->u_height)>>1; framingCtx->FramingYuv[1].u_topleft = 0; framingCtx->FramingYuv[1].u_stride = (framingCtx->FramingRgb->u_width)>>1; framingCtx->FramingYuv[1].pac_data = framingCtx->FramingYuv[0].pac_data + framingCtx->FramingYuv[0].u_width * framingCtx->FramingYuv[0].u_height; framingCtx->FramingYuv[2].u_width = (framingCtx->FramingRgb->u_width)>>1; framingCtx->FramingYuv[2].u_height = (framingCtx->FramingRgb->u_height)>>1; framingCtx->FramingYuv[2].u_topleft = 0; framingCtx->FramingYuv[2].u_stride = (framingCtx->FramingRgb->u_width)>>1; framingCtx->FramingYuv[2].pac_data = framingCtx->FramingYuv[1].pac_data + framingCtx->FramingYuv[1].u_width * framingCtx->FramingYuv[1].u_height; framingCtx->duration = 0; framingCtx->previousClipTime = -1; framingCtx->previewOffsetClipTime = -1; } return err; } M4OSA_ERR applyColorEffect(M4xVSS_VideoEffectType colorEffect, M4VIFI_ImagePlane *planeIn, M4VIFI_ImagePlane *planeOut, M4VIFI_UInt8 *buffer1, M4VIFI_UInt8 *buffer2, M4OSA_UInt16 rgbColorData) { M4xVSS_ColorStruct colorContext; M4OSA_ERR err = M4NO_ERROR; colorContext.colorEffectType = colorEffect; colorContext.rgb16ColorData = rgbColorData; err = M4VSS3GPP_externalVideoEffectColor( (M4OSA_Void *)&colorContext, planeIn, planeOut, NULL, colorEffect); if(err != M4NO_ERROR) { ALOGV("M4VSS3GPP_externalVideoEffectColor(%d) error %d", colorEffect, err); if(NULL != buffer1) { free(buffer1); buffer1 = NULL; } if(NULL != buffer2) { free(buffer2); buffer2 = NULL; } return err; } // The out plane now becomes the in plane for adding other effects swapImagePlanes(planeIn, planeOut, buffer1, buffer2); return err; } M4OSA_ERR applyLumaEffect(M4VSS3GPP_VideoEffectType videoEffect, M4VIFI_ImagePlane *planeIn, M4VIFI_ImagePlane *planeOut, M4VIFI_UInt8 *buffer1, M4VIFI_UInt8 *buffer2, M4OSA_Int32 lum_factor) { M4OSA_ERR err = M4NO_ERROR; err = M4VFL_modifyLumaWithScale( (M4ViComImagePlane*)planeIn,(M4ViComImagePlane*)planeOut, lum_factor, NULL); if(err != M4NO_ERROR) { ALOGE("M4VFL_modifyLumaWithScale(%d) error %d", videoEffect, (int)err); if(NULL != buffer1) { free(buffer1); buffer1= NULL; } if(NULL != buffer2) { free(buffer2); buffer2= NULL; } return err; } // The out plane now becomes the in plane for adding other effects swapImagePlanes(planeIn, planeOut,(M4VIFI_UInt8 *)buffer1, (M4VIFI_UInt8 *)buffer2); return err; } M4OSA_ERR applyEffectsAndRenderingMode(vePostProcessParams *params, M4OSA_UInt32 reportedWidth, M4OSA_UInt32 reportedHeight) { M4OSA_ERR err = M4NO_ERROR; M4VIFI_ImagePlane planeIn[3], planeOut[3]; M4VIFI_UInt8 *finalOutputBuffer = NULL, *tempOutputBuffer= NULL; M4OSA_Double percentageDone =0; M4OSA_Int32 lum_factor; M4VSS3GPP_ExternalProgress extProgress; M4xVSS_FiftiesStruct fiftiesCtx; M4OSA_UInt32 frameSize = 0, i=0; frameSize = (params->videoWidth*params->videoHeight*3) >> 1; finalOutputBuffer = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc(frameSize, M4VS, (M4OSA_Char*)("lvpp finalOutputBuffer")); if(finalOutputBuffer == NULL) { ALOGE("applyEffectsAndRenderingMode: malloc error"); return M4ERR_ALLOC; } // allocate the tempOutputBuffer tempOutputBuffer = (M4VIFI_UInt8*)M4OSA_32bitAlignedMalloc( ((params->videoHeight*params->videoWidth*3)>>1), M4VS, (M4OSA_Char*)("lvpp colorBuffer")); if(tempOutputBuffer == NULL) { ALOGE("applyEffectsAndRenderingMode: malloc error tempOutputBuffer"); if(NULL != finalOutputBuffer) { free(finalOutputBuffer); finalOutputBuffer = NULL; } return M4ERR_ALLOC; } // Initialize the In plane prepareYUV420ImagePlane(planeIn, params->videoWidth, params->videoHeight, params->vidBuffer, reportedWidth, reportedHeight); // Initialize the Out plane prepareYUV420ImagePlane(planeOut, params->videoWidth, params->videoHeight, (M4VIFI_UInt8 *)tempOutputBuffer, params->videoWidth, params->videoHeight); // The planeIn contains the YUV420 input data to postprocessing node // and planeOut will contain the YUV420 data with effect // In each successive if condition, apply filter to successive // output YUV frame so that concurrent effects are both applied if(params->currentVideoEffect & VIDEO_EFFECT_BLACKANDWHITE) { err = applyColorEffect(M4xVSS_kVideoEffectType_BlackAndWhite, planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, (M4VIFI_UInt8 *)tempOutputBuffer, 0); if(err != M4NO_ERROR) { return err; } } if(params->currentVideoEffect & VIDEO_EFFECT_PINK) { err = applyColorEffect(M4xVSS_kVideoEffectType_Pink, planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, (M4VIFI_UInt8 *)tempOutputBuffer, 0); if(err != M4NO_ERROR) { return err; } } if(params->currentVideoEffect & VIDEO_EFFECT_GREEN) { err = applyColorEffect(M4xVSS_kVideoEffectType_Green, planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, (M4VIFI_UInt8 *)tempOutputBuffer, 0); if(err != M4NO_ERROR) { return err; } } if(params->currentVideoEffect & VIDEO_EFFECT_SEPIA) { err = applyColorEffect(M4xVSS_kVideoEffectType_Sepia, planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, (M4VIFI_UInt8 *)tempOutputBuffer, 0); if(err != M4NO_ERROR) { return err; } } if(params->currentVideoEffect & VIDEO_EFFECT_NEGATIVE) { err = applyColorEffect(M4xVSS_kVideoEffectType_Negative, planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, (M4VIFI_UInt8 *)tempOutputBuffer, 0); if(err != M4NO_ERROR) { return err; } } if(params->currentVideoEffect & VIDEO_EFFECT_GRADIENT) { // find the effect in effectSettings array for(i=0;inumberEffects;i++) { if(params->effectsSettings[i].VideoEffectType == (M4VSS3GPP_VideoEffectType)M4xVSS_kVideoEffectType_Gradient) break; } err = applyColorEffect(M4xVSS_kVideoEffectType_Gradient, planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, (M4VIFI_UInt8 *)tempOutputBuffer, params->effectsSettings[i].xVSS.uiRgb16InputColor); if(err != M4NO_ERROR) { return err; } } if(params->currentVideoEffect & VIDEO_EFFECT_COLOR_RGB16) { // Find the effect in effectSettings array for(i=0;inumberEffects;i++) { if(params->effectsSettings[i].VideoEffectType == (M4VSS3GPP_VideoEffectType)M4xVSS_kVideoEffectType_ColorRGB16) break; } err = applyColorEffect(M4xVSS_kVideoEffectType_ColorRGB16, planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, (M4VIFI_UInt8 *)tempOutputBuffer, params->effectsSettings[i].xVSS.uiRgb16InputColor); if(err != M4NO_ERROR) { return err; } } if(params->currentVideoEffect & VIDEO_EFFECT_FIFTIES) { // Find the effect in effectSettings array for(i=0;inumberEffects;i++) { if(params->effectsSettings[i].VideoEffectType == (M4VSS3GPP_VideoEffectType)M4xVSS_kVideoEffectType_Fifties) break; } if(i < params->numberEffects) { computeProgressForVideoEffect(params->timeMs, params->effectsSettings[i].uiStartTime, params->effectsSettings[i].uiDuration, &extProgress); if(params->isFiftiesEffectStarted) { fiftiesCtx.previousClipTime = -1; } fiftiesCtx.fiftiesEffectDuration = 1000/params->effectsSettings[i].xVSS.uiFiftiesOutFrameRate; fiftiesCtx.shiftRandomValue = 0; fiftiesCtx.stripeRandomValue = 0; err = M4VSS3GPP_externalVideoEffectFifties( (M4OSA_Void *)&fiftiesCtx, planeIn, planeOut, &extProgress, M4xVSS_kVideoEffectType_Fifties); if(err != M4NO_ERROR) { ALOGE("M4VSS3GPP_externalVideoEffectFifties error 0x%x", (unsigned int)err); if(NULL != finalOutputBuffer) { free(finalOutputBuffer); finalOutputBuffer = NULL; } if(NULL != tempOutputBuffer) { free(tempOutputBuffer); tempOutputBuffer = NULL; } return err; } // The out plane now becomes the in plane for adding other effects swapImagePlanes(planeIn, planeOut,(M4VIFI_UInt8 *)finalOutputBuffer, (M4VIFI_UInt8 *)tempOutputBuffer); } } if(params->currentVideoEffect & VIDEO_EFFECT_FRAMING) { M4xVSS_FramingStruct framingCtx; // Find the effect in effectSettings array for(i=0;inumberEffects;i++) { if(params->effectsSettings[i].VideoEffectType == (M4VSS3GPP_VideoEffectType)M4xVSS_kVideoEffectType_Framing) { if((params->effectsSettings[i].uiStartTime <= params->timeMs + params->timeOffset) && ((params->effectsSettings[i].uiStartTime+ params->effectsSettings[i].uiDuration) >= params->timeMs + params->timeOffset)) { break; } } } if(i < params->numberEffects) { computeProgressForVideoEffect(params->timeMs, params->effectsSettings[i].uiStartTime, params->effectsSettings[i].uiDuration, &extProgress); err = prepareFramingStructure(&framingCtx, params->effectsSettings, i, params->overlayFrameRGBBuffer, params->overlayFrameYUVBuffer); if(err == M4NO_ERROR) { err = M4VSS3GPP_externalVideoEffectFraming( (M4OSA_Void *)&framingCtx, planeIn, planeOut, &extProgress, M4xVSS_kVideoEffectType_Framing); } free(framingCtx.alphaBlendingStruct); if(framingCtx.FramingYuv != NULL) { free(framingCtx.FramingYuv); framingCtx.FramingYuv = NULL; } //If prepareFramingStructure / M4VSS3GPP_externalVideoEffectFraming // returned error, then return from function if(err != M4NO_ERROR) { if(NULL != finalOutputBuffer) { free(finalOutputBuffer); finalOutputBuffer = NULL; } if(NULL != tempOutputBuffer) { free(tempOutputBuffer); tempOutputBuffer = NULL; } return err; } // The out plane now becomes the in plane for adding other effects swapImagePlanes(planeIn, planeOut,(M4VIFI_UInt8 *)finalOutputBuffer, (M4VIFI_UInt8 *)tempOutputBuffer); } } if(params->currentVideoEffect & VIDEO_EFFECT_FADEFROMBLACK) { /* find the effect in effectSettings array*/ for(i=0;inumberEffects;i++) { if(params->effectsSettings[i].VideoEffectType == M4VSS3GPP_kVideoEffectType_FadeFromBlack) break; } if(i < params->numberEffects) { computePercentageDone(params->timeMs, params->effectsSettings[i].uiStartTime, params->effectsSettings[i].uiDuration, &percentageDone); // Compute where we are in the effect (scale is 0->1024) lum_factor = (M4OSA_Int32)( percentageDone * 1024 ); // Apply the darkening effect err = applyLumaEffect(M4VSS3GPP_kVideoEffectType_FadeFromBlack, planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, (M4VIFI_UInt8 *)tempOutputBuffer, lum_factor); if(err != M4NO_ERROR) { return err; } } } if(params->currentVideoEffect & VIDEO_EFFECT_FADETOBLACK) { // Find the effect in effectSettings array for(i=0;inumberEffects;i++) { if(params->effectsSettings[i].VideoEffectType == M4VSS3GPP_kVideoEffectType_FadeToBlack) break; } if(i < params->numberEffects) { computePercentageDone(params->timeMs, params->effectsSettings[i].uiStartTime, params->effectsSettings[i].uiDuration, &percentageDone); // Compute where we are in the effect (scale is 0->1024) lum_factor = (M4OSA_Int32)( (1.0-percentageDone) * 1024 ); // Apply the darkening effect err = applyLumaEffect(M4VSS3GPP_kVideoEffectType_FadeToBlack, planeIn, planeOut, (M4VIFI_UInt8 *)finalOutputBuffer, (M4VIFI_UInt8 *)tempOutputBuffer, lum_factor); if(err != M4NO_ERROR) { return err; } } } ALOGV("doMediaRendering CALL getBuffer()"); // Set the output YUV420 plane to be compatible with YV12 format // W & H even // YVU instead of YUV // align buffers on 32 bits // Y plane //in YV12 format, sizes must be even M4OSA_UInt32 yv12PlaneWidth = ((params->outVideoWidth +1)>>1)<<1; M4OSA_UInt32 yv12PlaneHeight = ((params->outVideoHeight+1)>>1)<<1; prepareYV12ImagePlane(planeOut, yv12PlaneWidth, yv12PlaneHeight, (M4OSA_UInt32)params->outBufferStride, (M4VIFI_UInt8 *)params->pOutBuffer); err = applyRenderingMode(planeIn, planeOut, params->renderingMode); if(M4OSA_NULL != finalOutputBuffer) { free(finalOutputBuffer); finalOutputBuffer= M4OSA_NULL; } if(M4OSA_NULL != tempOutputBuffer) { free(tempOutputBuffer); tempOutputBuffer = M4OSA_NULL; } if(err != M4NO_ERROR) { ALOGV("doVideoPostProcessing: applyRenderingMode returned err=%d",err); return err; } return M4NO_ERROR; } android::status_t getVideoSizeByResolution( M4VIDEOEDITING_VideoFrameSize resolution, uint32_t *pWidth, uint32_t *pHeight) { uint32_t frameWidth, frameHeight; if (pWidth == NULL) { ALOGE("getVideoFrameSizeByResolution invalid pointer for pWidth"); return android::BAD_VALUE; } if (pHeight == NULL) { ALOGE("getVideoFrameSizeByResolution invalid pointer for pHeight"); return android::BAD_VALUE; } switch (resolution) { case M4VIDEOEDITING_kSQCIF: frameWidth = 128; frameHeight = 96; break; case M4VIDEOEDITING_kQQVGA: frameWidth = 160; frameHeight = 120; break; case M4VIDEOEDITING_kQCIF: frameWidth = 176; frameHeight = 144; break; case M4VIDEOEDITING_kQVGA: frameWidth = 320; frameHeight = 240; break; case M4VIDEOEDITING_kCIF: frameWidth = 352; frameHeight = 288; break; case M4VIDEOEDITING_kVGA: frameWidth = 640; frameHeight = 480; break; case M4VIDEOEDITING_kWVGA: frameWidth = 800; frameHeight = 480; break; case M4VIDEOEDITING_kNTSC: frameWidth = 720; frameHeight = 480; break; case M4VIDEOEDITING_k640_360: frameWidth = 640; frameHeight = 360; break; case M4VIDEOEDITING_k854_480: frameWidth = 854; frameHeight = 480; break; case M4VIDEOEDITING_k1280_720: frameWidth = 1280; frameHeight = 720; break; case M4VIDEOEDITING_k1080_720: frameWidth = 1080; frameHeight = 720; break; case M4VIDEOEDITING_k960_720: frameWidth = 960; frameHeight = 720; break; case M4VIDEOEDITING_k1920_1080: frameWidth = 1920; frameHeight = 1080; break; default: ALOGE("Unsupported video resolution %d.", resolution); return android::BAD_VALUE; } *pWidth = frameWidth; *pHeight = frameHeight; return android::OK; } M4VIFI_UInt8 M4VIFI_Rotate90LeftYUV420toYUV420(void* pUserData, M4VIFI_ImagePlane *pPlaneIn, M4VIFI_ImagePlane *pPlaneOut) { M4VIFI_Int32 plane_number; M4VIFI_UInt32 i,j, u_stride; M4VIFI_UInt8 *p_buf_src, *p_buf_dest; /**< Loop on Y,U and V planes */ for (plane_number = 0; plane_number < 3; plane_number++) { /**< Get adresses of first valid pixel in input and output buffer */ /**< As we have a -90° rotation, first needed pixel is the upper-right one */ p_buf_src = &(pPlaneIn[plane_number].pac_data[pPlaneIn[plane_number].u_topleft]) + pPlaneOut[plane_number].u_height - 1 ; p_buf_dest = &(pPlaneOut[plane_number].pac_data[pPlaneOut[plane_number].u_topleft]); u_stride = pPlaneIn[plane_number].u_stride; /**< Loop on output rows */ for (i = 0; i < pPlaneOut[plane_number].u_height; i++) { /**< Loop on all output pixels in a row */ for (j = 0; j < pPlaneOut[plane_number].u_width; j++) { *p_buf_dest++= *p_buf_src; p_buf_src += u_stride; /**< Go to the next row */ } /**< Go on next row of the output frame */ p_buf_dest += pPlaneOut[plane_number].u_stride - pPlaneOut[plane_number].u_width; /**< Go to next pixel in the last row of the input frame*/ p_buf_src -= pPlaneIn[plane_number].u_stride * pPlaneOut[plane_number].u_width + 1 ; } } return M4VIFI_OK; } M4VIFI_UInt8 M4VIFI_Rotate90RightYUV420toYUV420(void* pUserData, M4VIFI_ImagePlane *pPlaneIn, M4VIFI_ImagePlane *pPlaneOut) { M4VIFI_Int32 plane_number; M4VIFI_UInt32 i,j, u_stride; M4VIFI_UInt8 *p_buf_src, *p_buf_dest; /**< Loop on Y,U and V planes */ for (plane_number = 0; plane_number < 3; plane_number++) { /**< Get adresses of first valid pixel in input and output buffer */ /**< As we have a +90° rotation, first needed pixel is the left-down one */ p_buf_src = &(pPlaneIn[plane_number].pac_data[pPlaneIn[plane_number].u_topleft]) + (pPlaneIn[plane_number].u_stride * (pPlaneOut[plane_number].u_width - 1)); p_buf_dest = &(pPlaneOut[plane_number].pac_data[pPlaneOut[plane_number].u_topleft]); u_stride = pPlaneIn[plane_number].u_stride; /**< Loop on output rows */ for (i = 0; i < pPlaneOut[plane_number].u_height; i++) { /**< Loop on all output pixels in a row */ for (j = 0; j < pPlaneOut[plane_number].u_width; j++) { *p_buf_dest++= *p_buf_src; p_buf_src -= u_stride; /**< Go to the previous row */ } /**< Go on next row of the output frame */ p_buf_dest += pPlaneOut[plane_number].u_stride - pPlaneOut[plane_number].u_width; /**< Go to next pixel in the last row of the input frame*/ p_buf_src += pPlaneIn[plane_number].u_stride * pPlaneOut[plane_number].u_width +1 ; } } return M4VIFI_OK; } M4VIFI_UInt8 M4VIFI_Rotate180YUV420toYUV420(void* pUserData, M4VIFI_ImagePlane *pPlaneIn, M4VIFI_ImagePlane *pPlaneOut) { M4VIFI_Int32 plane_number; M4VIFI_UInt32 i,j; M4VIFI_UInt8 *p_buf_src, *p_buf_dest, temp_pix1; /**< Loop on Y,U and V planes */ for (plane_number = 0; plane_number < 3; plane_number++) { /**< Get adresses of first valid pixel in input and output buffer */ p_buf_src = &(pPlaneIn[plane_number].pac_data[pPlaneIn[plane_number].u_topleft]); p_buf_dest = &(pPlaneOut[plane_number].pac_data[pPlaneOut[plane_number].u_topleft]); /**< If pPlaneIn = pPlaneOut, the algorithm will be different */ if (p_buf_src == p_buf_dest) { /**< Get Address of last pixel in the last row of the frame */ p_buf_dest += pPlaneOut[plane_number].u_stride*(pPlaneOut[plane_number].u_height-1) + pPlaneOut[plane_number].u_width - 1; /**< We loop (height/2) times on the rows. * In case u_height is odd, the row at the middle of the frame * has to be processed as must be mirrored */ for (i = 0; i < ((pPlaneOut[plane_number].u_height)>>1); i++) { for (j = 0; j < pPlaneOut[plane_number].u_width; j++) { temp_pix1= *p_buf_dest; *p_buf_dest--= *p_buf_src; *p_buf_src++ = temp_pix1; } /**< Go on next row in top of frame */ p_buf_src += pPlaneOut[plane_number].u_stride - pPlaneOut[plane_number].u_width; /**< Go to the last pixel in previous row in bottom of frame*/ p_buf_dest -= pPlaneOut[plane_number].u_stride - pPlaneOut[plane_number].u_width; } /**< Mirror middle row in case height is odd */ if ((pPlaneOut[plane_number].u_height%2)!= 0) { p_buf_src = &(pPlaneOut[plane_number].pac_data[pPlaneIn[plane_number].u_topleft]); p_buf_src += pPlaneOut[plane_number].u_stride*(pPlaneOut[plane_number].u_height>>1); p_buf_dest = p_buf_src + pPlaneOut[plane_number].u_width; /**< We loop u_width/2 times on this row. * In case u_width is odd, the pixel at the middle of this row * remains unchanged */ for (j = 0; j < (pPlaneOut[plane_number].u_width>>1); j++) { temp_pix1= *p_buf_dest; *p_buf_dest--= *p_buf_src; *p_buf_src++ = temp_pix1; } } } else { /**< Get Address of last pixel in the last row of the output frame */ p_buf_dest += pPlaneOut[plane_number].u_stride*(pPlaneOut[plane_number].u_height-1) + pPlaneIn[plane_number].u_width - 1; /**< Loop on rows */ for (i = 0; i < pPlaneOut[plane_number].u_height; i++) { for (j = 0; j < pPlaneOut[plane_number].u_width; j++) { *p_buf_dest--= *p_buf_src++; } /**< Go on next row in top of input frame */ p_buf_src += pPlaneIn[plane_number].u_stride - pPlaneOut[plane_number].u_width; /**< Go to last pixel of previous row in bottom of input frame*/ p_buf_dest -= pPlaneOut[plane_number].u_stride - pPlaneOut[plane_number].u_width; } } } return M4VIFI_OK; } M4OSA_ERR applyVideoRotation(M4OSA_Void* pBuffer, M4OSA_UInt32 width, M4OSA_UInt32 height, M4OSA_UInt32 rotation) { M4OSA_ERR err = M4NO_ERROR; M4VIFI_ImagePlane planeIn[3], planeOut[3]; if (pBuffer == M4OSA_NULL) { ALOGE("applyVideoRotation: NULL input frame"); return M4ERR_PARAMETER; } M4OSA_UInt8* outPtr = (M4OSA_UInt8 *)M4OSA_32bitAlignedMalloc( (width*height*1.5), M4VS, (M4OSA_Char*)("rotation out ptr")); if (outPtr == M4OSA_NULL) { return M4ERR_ALLOC; } // In plane prepareYUV420ImagePlane(planeIn, width, height, (M4VIFI_UInt8 *)pBuffer, width, height); // Out plane if (rotation != 180) { prepareYUV420ImagePlane(planeOut, height, width, outPtr, height, width); } switch(rotation) { case 90: M4VIFI_Rotate90RightYUV420toYUV420(M4OSA_NULL, planeIn, planeOut); memcpy(pBuffer, (void *)outPtr, (width*height*1.5)); break; case 180: // In plane rotation, so planeOut = planeIn M4VIFI_Rotate180YUV420toYUV420(M4OSA_NULL, planeIn, planeIn); break; case 270: M4VIFI_Rotate90LeftYUV420toYUV420(M4OSA_NULL, planeIn, planeOut); memcpy(pBuffer, (void *)outPtr, (width*height*1.5)); break; default: ALOGE("invalid rotation param %d", (int)rotation); err = M4ERR_PARAMETER; break; } free((void *)outPtr); return err; }