1
2 /*
3 * Copyright 2001-2008 Texas Instruments - http://www.ti.com/
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 /* ====================================================================
18 * Texas Instruments OMAP(TM) Platform Software
19 * (c) Copyright Texas Instruments, Incorporated. All Rights Reserved.
20 *
21 * Use of this software is controlled by the terms and conditions found
22 * in the license agreement under which this software has been supplied.
23 * ==================================================================== */
24 /**
25 * @file JPEGTestEnc.c
26 *
27 * This file implements OMX Component for JPEG encoder that
28 * is fully compliant with the OMX specification 1.5.
29 *
30 * @path $(CSLPATH)\src
31 *
32 * @rev 0.1
33 */
34 /* -------------------------------------------------------------------------------- */
35 /* ================================================================================
36 *!
37 *! Revision History
38 *! ===================================
39 *!
40 *! 22-May-2006 mf: Revisions appear in reverse chronological order;
41 *! that is, newest first. The date format is dd-Mon-yyyy.
42 * ================================================================================= */
43
44 /*utilities includes */
45 #ifdef UNDER_CE
46 #include <windows.h>
47 #endif
48 #include <stdio.h>
49 #include <stdlib.h>
50 #include <stdarg.h>
51 #include <string.h>
52 #include <sched.h>
53 #include <unistd.h>
54 #include <sys/types.h>
55 #include <sys/select.h>
56 #include <time.h>
57 //#include <mcheck.h>
58 #include <getopt.h>
59 #include <signal.h>
60
61 /* OMX includes */
62 #include <OMX_Component.h>
63 #include "OMX_JpegEnc_CustomCmd.h"
64 #include "JPEGTestEnc.h"
65 #include "OMX_JpegEnc_Utils.h"
66
67 /* DSP recovery includes */
68 #include <qosregistry.h>
69 #include <qosti.h>
70 #include <dbapi.h>
71 #include <DSPManager.h>
72 #include <DSPProcessor.h>
73 #include <DSPProcessor_OEM.h>
74
75 #define STRESS
76 #define NSTRESSCASES 1
77 #define STRESSMULTILOAD 1
78 #define NUM_OF_PORTS 2
79 #define NUM_OF_BUFFERSJPEG 1
80
81 #ifdef UNDER_CE
82 OMX_STRING StrJpegEncoder= "OMX.TI.IMAGE.JPEG.ENC";
83 #else
84 OMX_STRING StrJpegEncoder= "OMX.TI.JPEG.Encoder";
85 #endif
86
87 OMX_U8 APPLICATION1_NOTHUMB[]={
88
89 /* 0 */0, 0, 0, 0, 0x45, 0x78, 0x69, 0x66, 0x00, 0x00, /* Indicate Exif Data*/
90
91 /* 10 */ 0x49, 0x49, /* "Intel" type byte align*/
92
93 0x2A, 0x00, /* Confirm "Intel" type byte align*/
94
95 /* 14 */ 0x08, 0x00, 0x00, 0x00, /* Offset to first IFDc*/
96
97 0x06, 0x00, /* Number of IFD as 1*/
98
99 /* 21 */0x0f, 0x01, /* TAG: Make*/
100
101 0x02, 0x00, /* Type: Data format is 0x0002, ASCII */
102
103 0x0c, 0x00, 0x00, 0x00, /* Count: number of chars*/
104
105 0x56, 0x00, 0x00, 0x00, /* Offset Make data*/
106
107 /* 33 */0x10, 0x01, /* TAG: Model*/
108
109 0x02, 0x00, /* Type: Data format is 0x0002, ASCII */
110
111 0x05, 0x00, 0x00, 0x00, /* Count: number of chars*/
112
113 0x62, 0x00, 0x00, 0x00, /* Offset Model data*/
114
115 /*45*/0x12, 0x01, /* TAG: Orientation*/
116
117 0x03, 0x00, /* Type: Data format is 0x0003, (short)*/
118
119 0x01, 0x00, 0x00, 0x00, /* Count: number of chars*/
120
121 0x01, 0x00, 0x00, 0x00, /* 1 means normal orientation*/
122
123 /*57*/0x31, 0x01, /* TAG: Software*/
124
125 0x02, 0x00, /* Type: ASCII*/
126
127 0x08, 0x00, 0x00, 0x00, /* Count: number of chars*/
128
129 0x67, 0x00, 0x00, 0x00, /* Offset*/
130
131 /*69*/0x3b, 0x01, /* TAG: Artist*/
132
133 0x02, 0x00, /* Type: ASCII*/
134
135 0x09, 0x00, 0x00, 0x00, /* Count: number of chars*/
136
137 0x6f, 0x00, 0x00, 0x00, /* Offset*/
138
139 /* 81 */0x69, 0x87, /* Exif SubIFD*/
140
141 /* 83 */ 0x04, 0x00, /* Data format is 0x0004, ULInt*/
142
143 0x01, 0x00, 0x00, 0x00, /* number of components is 1.*/
144
145 /*long integer data size is 4bytes/components, so total data length is 1x4=4bytes*/
146
147 /* 89 */ 0x78, 0x00,0x00, 0x00, /* Offset of Exif data*/
148
149 /*93*/0x9E, 0x00, 0x00, 0x00, /* Offset to next IFD. As we are saying only one directory( Number of IFD as 1) this indicate the offset of next IFD*/
150
151 /*97*/0x53, 0x61, 0x73, 0x6b, 0x65, 0x6e, 0x20, 0x26, 0x20, 0x54, 0x49, 0x00, /*Make*/
152
153 /*109*/0x4f, 0x4d, 0x41, 0x50,0x00, /*Model*/
154
155 /*114*/0x4f, 0x70, 0x65, 0x6e, 0x4d, 0x61, 0x78, 0x00, /*Software*/
156
157 /*122*/0x47, 0x65, 0x6f, 0x72, 0x67, 0x65, 0x20, 0x53, 0x00, /*Artist*/
158
159 /* exif ub-ID start Here */
160
161 /* 131 */ 0x03, 0x00, /* Number of Exif ID*/
162
163 0x00, 0x90, /* Exif Version*/
164
165 0x07, 0x00, /*Data format is 0x0007, undefined*/
166
167 0x04, 0x00, 0x00, 0x00, /* number of components is 4.*/
168
169 /*Undefined data size is 1bytes/components, so total data length is 4x1=4bytes*/
170
171 0x30, 0x32, 0x32, 0x30, /* Exif version number 30 32 32 30 meaning 0220 (2.2)*/
172
173 /* next IFD start Here */
174
175 /*169*/0x03, 0x00, /* Number of IFD1*/
176
177 /*171*/0x03, 0x01, /* Compression (0x0103)*/
178
179 0x03, 0x00, /*Data format is 0x0003 unsigned short,*/
180
181 0x01, 0x00, 0x00, 0x00, /* number of components is 1.*/
182
183 /*unsigned short data size is 2bytes/components, so total data length is 1x2=2bytes*/
184
185 /*183*/ 0x01, 0x02, /* JpegIFOffset (0x0201)*/
186
187 0x04, 0x00, /* Data format is 0x0004, ULInt*/
188
189 0x01, 0x00, 0x00, 0x00, /* number of components is 1.*/
190
191 /*195*/ 0x02, 0x02, /* JpegIFByteCount (0x0202)*/
192
193 0x04, 0x00, /* Data format is 0x0004, ULInt*/
194
195 0x01, 0x00, 0x00, 0x00, /* number of components is 1.*/
196
197 /*203*/ 0xff, 0xff,0xff, 0xff, /* Legth of thumbnail data*/
198
199 };
200
201 OMX_U8 APPLICATION1_THUMB[]={
202 /* 0 */0, 0, 0, 0, 0x45, 0x78, 0x69, 0x66, 0x00, 0x00, /* Indicate Exif Data*/
203 /* 10 */ 0x49, 0x49, /* "Intel" type byte align*/
204 0x2A, 0x00, /* Confirm "Intel" type byte align*/
205 /* 14 */ 0x08, 0x00, 0x00, 0x00, /* Offset to first IFDc*/
206 0x06, 0x00, /* Number of IFD as 1*/
207
208 /* 21 */0x0f, 0x01, /* TAG: Make*/
209 0x02, 0x00, /* Type: Data format is 0x0002, ASCII */
210 0x0c, 0x00, 0x00, 0x00, /* Count: number of chars*/
211 0x56, 0x00, 0x00, 0x00, /* Offset Make data*/
212
213 /* 33 */0x10, 0x01, /* TAG: Model*/
214 0x02, 0x00, /* Type: Data format is 0x0002, ASCII */
215 0x05, 0x00, 0x00, 0x00, /* Count: number of chars*/
216 0x62, 0x00, 0x00, 0x00, /* Offset Model data*/
217
218 /*45*/0x12, 0x01, /* TAG: Orientation*/
219 0x03, 0x00, /* Type: Data format is 0x0003, (short)*/
220 0x01, 0x00, 0x00, 0x00, /* Count: number of chars*/
221 0x01, 0x00, 0x00, 0x00, /* 1 means normal orientation*/
222
223 /*57*/0x31, 0x01, /* TAG: Software*/
224 0x02, 0x00, /* Type: ASCII*/
225 0x08, 0x00, 0x00, 0x00, /* Count: number of chars*/
226 0x67, 0x00, 0x00, 0x00, /* Offset*/
227
228 /*69*/0x3b, 0x01, /* TAG: Artist*/
229 0x02, 0x00, /* Type: ASCII*/
230 0x09, 0x00, 0x00, 0x00, /* Count: number of chars*/
231 0x6f, 0x00, 0x00, 0x00, /* Offset*/
232
233
234 /* 81 */0x69, 0x87, /* Exif SubIFD*/
235 /* 83 */ 0x04, 0x00, /* Data format is 0x0004, ULInt*/
236 0x01, 0x00, 0x00, 0x00, /* number of components is 1.*/
237 /*long integer data size is 4bytes/components, so total data length is 1x4=4bytes*/
238 /* 89 */ 0x78, 0x00,0x00, 0x00, /* Offset of Exif data*/
239
240 /*93*/0x9E, 0x00, 0x00, 0x00, /* Offset to next IFD. As we are saying only one directory( Number of IFD as 1) this indicate the offset of next IFD*/
241
242 /*97*/0x53, 0x61, 0x73, 0x6b, 0x65, 0x6e, 0x20, 0x26, 0x20, 0x54, 0x49, 0x00, /*Make*/
243
244 /*109*/0x4f, 0x4d, 0x41, 0x50,0x00, /*Model*/
245
246 /*114*/0x4f, 0x70, 0x65, 0x6e, 0x4d, 0x61, 0x78, 0x00, /*Software*/
247
248 /*122*/0x47, 0x65, 0x6f, 0x72, 0x67, 0x65, 0x20, 0x53, 0x00, /*Artist*/
249
250 /* exif ub-ID start Here */
251 /* 131 */ 0x03, 0x00, /* Number of Exif ID*/
252 0x00, 0x90, /* Exif Version*/
253 0x07, 0x00, /*Data format is 0x0007, undefined*/
254 0x04, 0x00, 0x00, 0x00, /* number of components is 4.*/
255 /*Undefined data size is 1bytes/components, so total data length is 4x1=4bytes*/
256 0x30, 0x32, 0x32, 0x30, /* Exif version number 30 32 32 30 meaning 0220 (2.2)*/
257
258 /*145*/0x02, 0xA0, /* Exif Image Width (0xA002)*/
259 0x04, 0x00, /* Data format is 0x0004, ULInt*/
260 0x01, 0x00, 0x00, 0x00, /* number of components is 1.*/
261 /* 153 */ 0xB0, 0x00,0x00, 0x00, /* Image width , 0x00000280 i.e. 640*/
262
263 /*157*/0x03, 0xA0, /* Exif Image Width (0xA003)*/
264 0x04, 0x00, /* Data format is 0x0004, ULInt*/
265 0x01, 0x00, 0x00, 0x00, /* number of components is 1.*/
266 /* 165 */ 0x90, 0x00,0x00, 0x00, /* Image Height , 0x000001E0 i.e. 480*/
267
268
269
270 /* next IFD start Here */
271 /*169*/0x03, 0x00, /* Number of IFD1*/
272 /*171*/0x03, 0x01, /* Compression (0x0103)*/
273 0x03, 0x00, /*Data format is 0x0003 unsigned short,*/
274 0x01, 0x00, 0x00, 0x00, /* number of components is 1.*/
275 /*unsigned short data size is 2bytes/components, so total data length is 1x2=2bytes*/
276
277 0x06, 0x00,0x00, 0x00, /* '6' means JPEG compression.*/
278 /*Shows compression method.
279 o '1' means no compression,
280 o '6' means JPEG compression.*/
281
282 /*183*/ 0x01, 0x02, /* JpegIFOffset (0x0201)*/
283 0x04, 0x00, /* Data format is 0x0004, ULInt*/
284 0x01, 0x00, 0x00, 0x00, /* number of components is 1.*/
285 /*191*/ 0xc4, 0x00,0x00, 0x00, /* Address 0f Thumbnail data*/
286
287 /*195*/ 0x02, 0x02, /* JpegIFByteCount (0x0202)*/
288 0x04, 0x00, /* Data format is 0x0004, ULInt*/
289 0x01, 0x00, 0x00, 0x00, /* number of components is 1.*/
290 /*203*/ 0xff, 0xff,0xff, 0xff, /* Legth of thumbnail data*/
291 };
292
293 /*Set the fist 4 bytes to 0*/
294 OMX_U8 APPLICATION13[200] = {
295 0x00, 0x00, 0x00, 0x00, /*We should set the first 4 bytes to 0 */
296 0x50, 0x68, 0x6f, 0x74, 0x6f, 0x73, 0x68, 0x6f, 0x70, 0x20, 0x33, 0x2e, 0x30, 0x00,/*Photoshop header*/
297 0x38, 0x42, 0x49, 0x4d, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
298 0x4e, /* Initial marker*/
299 /*IPTC Marker TAG Size of string*/
300 0x1c, 0x02, 0x78, 0x00, 0x20,
301 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, /*String of data (ASCII)*/
302 0x1c, 0x02, 0x7a, 0x00, 0x16,
303 0x49, 0x27,0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x61, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x72,
304 0x1c, 0x02, 0x5a, 0x00, 0x09,
305 0x4d, 0x6f, 0x6e, 0x74, 0x65, 0x72, 0x72, 0x65, 0x79,
306
307 };
308
309 OMX_U8 APPLICATION0[19]={0, 0, 0, 0,
310 0x4A, 0x46, 0x49, 0x46, 0x00, // JFIF Identifier
311 0x01, 0x02, // Version
312 0x00, // X and Y Unit Densities.
313 0x00, 0x08, // Horizontal Pixel density
314 0x00, 0x09, // Vertical Pixel density
315 0x00,
316 0x00,
317 0x00,
318 };
319
320 OMX_U8 APPLICATION5[6]={0xff,0xff,0xff,0xff,0xff,0xff};
321 const OMX_U8 CustomLumaQuantizationTable[64]= {
322 14, 10, 9, 14, 22, 30, 41, 51,
323 12, 12, 14, 19, 26, 58, 60, 55,
324 14, 13, 16, 24, 40, 57, 69, 56,
325 14, 17, 22, 29, 51, 87, 80, 62,
326 18, 22, 37, 56, 68, 109, 103, 77,
327 24, 35, 55, 64, 81, 104, 113, 92,
328 49, 64, 78, 87, 103, 121, 120, 101,
329 72, 92, 95, 98, 112, 100, 103, 99,
330 };
331
332 const OMX_U8 CustomChromaQuantizationTable[64]= {
333 15, 16, 22, 35, 99, 99, 99, 99,
334 18, 21, 26, 66, 99, 99, 99, 99,
335 24, 26, 56, 99, 99, 99, 99, 99,
336 47, 66, 99, 99, 99, 99, 99, 99,
337 99, 99, 99, 99, 99, 99, 99, 99,
338 99, 99, 99, 99, 99, 99, 99, 99,
339 99, 99, 99, 99, 99, 99, 99, 99,
340 99, 99, 99, 99, 99, 99, 99, 99
341 };
342
343 JPEGENC_CUSTOM_HUFFMAN_TABLE CustomHuffmanTable =
344 {
345 /* VLC Tables */
346 /*Set 1 for Y Component */
347 /*DC-Y*/
348 /*const unsigned int JPEGENC_DCHUFFY[12] */
349 /*Length[16]-Codeword[16]*/
350 {
351 0x00020000,
352 0x00030002,
353 0x00030003,
354 0x00030004,
355 0x00030005,
356 0x00030006,
357 0x0004000e,
358 0x0005001e,
359 0x0006003e,
360 0x0007007e,
361 0x000800fe,
362 0x000901fe
363 },
364
365 /*AC-Y*/
366 /*const unsigned int JPEGENC_ACHUFFY[16][16] */
367 /*Length[16]-Codeword[16]*/
368 {
369 {
370 0x0004000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
371 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
372 0x00000000, 0x00000000, 0x00000000, 0x000b07f9
373 },
374 {
375 0x00020000, 0x0004000c, 0x0005001c, 0x0006003a, 0x0006003b, 0x0007007a,
376 0x0007007b, 0x000800fa, 0x000901f8, 0x000901f9, 0x000901fa, 0x000a03f9,
377 0x000a03fa, 0x000b07f8, 0x0010ffeb, 0x0010fff5
378 },
379 {
380 0x00020001, 0x0005001b, 0x000800f9, 0x000901f7, 0x000a03f8, 0x000b07f7,
381 0x000c0ff6, 0x000c0ff7, 0x000f7fc0, 0x0010ffbe, 0x0010ffc7, 0x0010ffd0,
382 0x0010ffd9, 0x0010ffe2, 0x0010ffec, 0x0010fff6
383 },
384 {
385 0x00030004, 0x00070079, 0x000a03f7, 0x000c0ff5, 0x0010ff96, 0x0010ff9e,
386 0x0010ffa6, 0x0010ffae, 0x0010ffb6, 0x0010ffbf, 0x0010ffc8, 0x0010ffd1,
387 0x0010ffda, 0x0010ffe3, 0x0010ffed, 0x0010fff7
388 },
389 {
390 0x0004000b, 0x000901f6, 0x000c0ff4, 0x0010ff8f, 0x0010ff97, 0x0010ff9f,
391 0x0010ffa7, 0x0010ffaf, 0x0010ffb7, 0x0010ffc0, 0x0010ffc9, 0x0010ffd2,
392 0x0010ffdb, 0x0010ffe4, 0x0010ffee, 0x0010fff8
393 },
394 {
395 0x0005001a, 0x000b07f6, 0x0010ff89, 0x0010ff90, 0x0010ff98, 0x0010ffa0,
396 0x0010ffa8, 0x0010ffb0, 0x0010ffb8, 0x0010ffc1, 0x0010ffca, 0x0010ffd3,
397 0x0010ffdc, 0x0010ffe5, 0x0010ffef, 0x0010fff9
398 },
399 {
400 0x00070078, 0x0010ff84, 0x0010ff8a, 0x0010ff91, 0x0010ff99, 0x0010ffa1,
401 0x0010ffa9, 0x0010ffb1, 0x0010ffb9, 0x0010ffc2, 0x0010ffcb, 0x0010ffd4,
402 0x0010ffdd, 0x0010ffe6, 0x0010fff0, 0x0010fffa
403 },
404 {
405 0x000800f8, 0x0010ff85, 0x0010ff8b, 0x0010ff92, 0x0010ff9a, 0x0010ffa2,
406 0x0010ffaa, 0x0010ffb2, 0x0010ffba, 0x0010ffc3, 0x0010ffcc, 0x0010ffd5,
407 0x0010ffde, 0x0010ffe7, 0x0010fff1, 0x0010fffb
408 },
409 {
410 0x000a03f6, 0x0010ff86, 0x0010ff8c, 0x0010ff93, 0x0010ff9b, 0x0010ffa3,
411 0x0010ffab, 0x0010ffb3, 0x0010ffbb, 0x0010ffc4, 0x0010ffcd, 0x0010ffd6,
412 0x0010ffdf, 0x0010ffe8, 0x0010fff2, 0x0010fffc
413 },
414 {
415 0x0010ff82, 0x0010ff87, 0x0010ff8d, 0x0010ff94, 0x0010ff9c, 0x0010ffa4,
416 0x0010ffac, 0x0010ffb4, 0x0010ffbc, 0x0010ffc5, 0x0010ffce, 0x0010ffd7,
417 0x0010ffe0, 0x0010ffe9, 0x0010fff3, 0x0010fffd
418 },
419 {
420 0x0010ff83, 0x0010ff88, 0x0010ff8e, 0x0010ff95, 0x0010ff9d, 0x0010ffa5,
421 0x0010ffad, 0x0010ffb5, 0x0010ffbd, 0x0010ffc6, 0x0010ffcf, 0x0010ffd8,
422 0x0010ffe1, 0x0010ffea, 0x0010fff4, 0x0010fffe
423 },
424 {
425 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
426 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
427 0x00000000, 0x00000000, 0x00000000, 0x00000000
428 },
429 {
430 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
431 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
432 0x00000000, 0x00000000, 0x00000000, 0x00000000
433 },
434 {
435 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
436 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
437 0x00000000, 0x00000000, 0x00000000, 0x00000000
438 },
439 {
440 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
441 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
442 0x00000000, 0x00000000, 0x00000000, 0x00000000
443 },
444 {
445 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
446 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
447 0x00000000, 0x00000000, 0x00000000, 0x00000000
448 }
449 },
450
451 /*Set 2 for U & V Component */
452 /*DC-UV*/
453 /*const unsigned int JPEGENC_DCHUFFUV[12] */
454 /*Length[16]-Codeword[16]*/
455 {
456 0x00020000,
457 0x00020001,
458 0x00020002,
459 0x00030006,
460 0x0004000e,
461 0x0005001e,
462 0x0006003e,
463 0x0007007e,
464 0x000800fe,
465 0x000901fe,
466 0x000a03fe,
467 0x000b07fe
468 },
469
470 /*AC-UV*/
471 /*const unsigned int JPEGENC_ACHUFFUV[16][16] */
472 /*Length[16]-Codeword[16]*/
473 {
474 {
475 0x00020000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
476 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
477 0x00000000, 0x00000000, 0x00000000, 0x000a03fa
478 },
479 {
480 0x00020001, 0x0004000b, 0x0005001a, 0x0005001b, 0x0006003a, 0x0006003b,
481 0x00070079, 0x0007007a, 0x000800f9, 0x000901f7, 0x000901f8, 0x000901f9,
482 0x000901fa, 0x000b07f9, 0x000e3fe0, 0x000f7fc3
483 },
484 {
485 0x00030004, 0x00060039, 0x000800f7, 0x000800f8, 0x000901f6, 0x000a03f9,
486 0x000b07f7, 0x000b07f8, 0x0010ffb7, 0x0010ffc0, 0x0010ffc9, 0x0010ffd2,
487 0x0010ffdb, 0x0010ffe4, 0x0010ffed, 0x0010fff6
488 },
489 {
490 0x0004000a, 0x000800f6, 0x000a03f7, 0x000a03f8, 0x0010ff97, 0x0010ff9f,
491 0x0010ffa7, 0x0010ffaf, 0x0010ffb8, 0x0010ffc1, 0x0010ffca, 0x0010ffd3,
492 0x0010ffdc, 0x0010ffe5, 0x0010ffee, 0x0010fff7
493 },
494 {
495 0x00050018, 0x000901f5, 0x000c0ff6, 0x000c0ff7, 0x0010ff98, 0x0010ffa0,
496 0x0010ffa8, 0x0010ffb0, 0x0010ffb9, 0x0010ffc2, 0x0010ffcb, 0x0010ffd4,
497 0x0010ffdd, 0x0010ffe6, 0x0010ffef, 0x0010fff8
498 },
499 {
500 0x00050019, 0x000b07f6, 0x000f7fc2, 0x0010ff91, 0x0010ff99, 0x0010ffa1,
501 0x0010ffa9, 0x0010ffb1, 0x0010ffba, 0x0010ffc3, 0x0010ffcc, 0x0010ffd5,
502 0x0010ffde, 0x0010ffe7, 0x0010fff0, 0x0010fff9
503 },
504 {
505 0x00060038, 0x000c0ff5, 0x0010ff8c, 0x0010ff92, 0x0010ff9a, 0x0010ffa2,
506 0x0010ffaa, 0x0010ffb2, 0x0010ffbb, 0x0010ffc4, 0x0010ffcd, 0x0010ffd6,
507 0x0010ffdf, 0x0010ffe8, 0x0010fff1, 0x0010fffa
508 },
509 {
510 0x00070078, 0x0010ff88, 0x0010ff8d, 0x0010ff93, 0x0010ff9b, 0x0010ffa3,
511 0x0010ffab, 0x0010ffb3, 0x0010ffbc, 0x0010ffc5, 0x0010ffce, 0x0010ffd7,
512 0x0010ffe0, 0x0010ffe9, 0x0010fff2, 0x0010fffb
513 },
514 {
515 0x000901f4, 0x0010ff89, 0x0010ff8e, 0x0010ff94, 0x0010ff9c, 0x0010ffa4,
516 0x0010ffac, 0x0010ffb4, 0x0010ffbd, 0x0010ffc6, 0x0010ffcf, 0x0010ffd8,
517 0x0010ffe1, 0x0010ffea, 0x0010fff3, 0x0010fffc
518 },
519 {
520 0x000a03f6, 0x0010ff8a, 0x0010ff8f, 0x0010ff95, 0x0010ff9d, 0x0010ffa5,
521 0x0010ffad, 0x0010ffb5, 0x0010ffbe, 0x0010ffc7, 0x0010ffd0, 0x0010ffd9,
522 0x0010ffe2, 0x0010ffeb, 0x0010fff4, 0x0010fffd
523 },
524 {
525 0x000c0ff4, 0x0010ff8b, 0x0010ff90, 0x0010ff96, 0x0010ff9e, 0x0010ffa6,
526 0x0010ffae, 0x0010ffb6, 0x0010ffbf, 0x0010ffc8, 0x0010ffd1, 0x0010ffda,
527 0x0010ffe3, 0x0010ffec, 0x0010fff5, 0x0010fffe
528 },
529 {
530 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
531 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
532 0x00000000, 0x00000000, 0x00000000, 0x00000000
533 },
534 {
535 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
536 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
537 0x00000000, 0x00000000, 0x00000000, 0x00000000
538 },
539 {
540 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
541 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
542 0x00000000, 0x00000000, 0x00000000, 0x00000000
543 },
544 {
545 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
546 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
547 0x00000000, 0x00000000, 0x00000000, 0x00000000
548 },
549 {
550 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
551 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
552 0x00000000, 0x00000000, 0x00000000, 0x00000000
553 }
554 },
555
556 /* DHT Marker */
557 /* lum_dc_codelens */
558 {0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0},
559 /* lum_dc_ncodes */
560 16,
561 /* lum_dc_symbols */
562 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
563 /* lum_dc_nsymbols */
564 12,
565 /* lum_ac_codelens */
566 {0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d},
567 /* lum_ac_ncodes */
568 16,
569 /* lum_ac_symbols */
570 {
571 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
572 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
573 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
574 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
575 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
576 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
577 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
578 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
579 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
580 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
581 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
582 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
583 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
584 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
585 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
586 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
587 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
588 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
589 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
590 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
591 0xf9, 0xfa
592 },
593
594 /* lum_ac_nsymbols */
595 162,
596 /* chm_dc_codelens */
597 {0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
598 /* chm_dc_ncodes */
599 16,
600 /* chm_dc_symbols */
601 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
602 /* chm_dc_nsymbols */
603 12,
604 /* chm_ac_codelens */
605 {0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77},
606 /* chm_ac_ncodes */
607 16,
608 /* chm_ac_symbols */
609 {
610 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
611 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
612 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
613 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
614 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
615 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
616 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
617 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
618 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
619 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
620 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
621 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
622 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
623 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
624 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
625 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
626 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
627 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
628 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
629 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
630 0xf9, 0xfa
631 },
632 /* chm_ac_nsymbols */
633 162
634 };
635
636
637 typedef unsigned char uchar;
638 /**
639 * Pipe used to communicate back to the main thread from the component thread;
640 **/
641 int IpBuf_Pipe[2];
642 int OpBuf_Pipe[2];
643 int Event_Pipe[2];
644
645 /* the FLAG when we need to DeInit the OMX */
646 int DEINIT_FLAG = 0;
647
648 /* Flag set when component is preempted */
649 int bPreempted=0;
650
651 /* Hardware error flag */
652 OMX_BOOL bError = OMX_FALSE;
653
654 /*function prototypes */
655 inline int maxint(int a, int b);
656 OMX_ERRORTYPE SetMarkers(OMX_HANDLETYPE pHandle, IMAGE_INFO *imageinfo, OMX_CONFIG_RECTTYPE sCrop, int nWidth, int nHeight);
657
658 #ifdef DSP_MMU_FAULT_HANDLING
659 int LoadBaseImage();
660 #endif
661
662 /*Routine to get the maximum of 2 integers */
maxint(int a,int b)663 inline int maxint(int a, int b)
664 {
665 return(a>b) ? a : b;
666 }
667
668
669 /**
670 * This method will wait for the component or mixer to get to the correct
671 * state. It is not a real implementation, but just simulates what a real
672 * wait routine may do.
673 **/
WaitForState(OMX_HANDLETYPE * pHandle,OMX_STATETYPE DesiredState)674 static OMX_ERRORTYPE WaitForState(OMX_HANDLETYPE* pHandle,
675 OMX_STATETYPE DesiredState)
676 {
677 OMX_STATETYPE CurState = OMX_StateInvalid;
678 OMX_ERRORTYPE eError = OMX_ErrorNone;
679 int nCnt = 0;
680 OMX_COMPONENTTYPE *pComponent = (OMX_COMPONENTTYPE *)pHandle;
681
682 PRINT("Inside Test Application WaitForState function\n");
683 eError = pComponent->GetState(pHandle, &CurState);
684 while ( (eError == OMX_ErrorNone) &&
685 (CurState != DesiredState)) {
686 sched_yield();
687 /*sleep(1);*/
688 if ( nCnt++ == 0xFFFFFFFE ) {
689 fprintf(stderr, "Press CTL-C to continue\n");
690 }
691
692 eError = pComponent->GetState(pHandle, &CurState);
693 if (CurState == OMX_StateInvalid && DesiredState != OMX_StateInvalid) {
694 eError = OMX_ErrorInvalidState;
695 break;
696 }
697 }
698
699 if ( eError != OMX_ErrorNone ) {
700 PRINT("Error: Couldn't get state for component or sent to invalid state because of an error.\n");
701 return eError;
702 }
703 return OMX_ErrorNone;
704 }
705
EventHandler(OMX_HANDLETYPE hComponent,OMX_PTR pAppData,OMX_EVENTTYPE eEvent,OMX_U32 nData1,OMX_U32 data2,OMX_PTR pEventData)706 OMX_ERRORTYPE EventHandler(OMX_HANDLETYPE hComponent,OMX_PTR pAppData,OMX_EVENTTYPE eEvent,
707 OMX_U32 nData1, OMX_U32 data2, OMX_PTR pEventData)
708 {
709 OMX_COMPONENTTYPE *pComponent = (OMX_COMPONENTTYPE *)hComponent;
710 OMX_STATETYPE state;
711 OMX_ERRORTYPE eError;
712 JPEGE_EVENTPRIVATE MyEvent;
713
714 MyEvent.eEvent = eEvent;
715 MyEvent.nData1 = nData1;
716 MyEvent.nData2 = data2;
717 MyEvent.pAppData = pAppData;
718 MyEvent.pEventInfo = pEventData;
719 PRINT("Inside Test Application EventHandler function\n");
720 eError = pComponent->GetState (hComponent, &state);
721
722 if ( eError != OMX_ErrorNone ) {
723 PRINT("Error: From JPEGENC_GetState\n");
724 }
725 switch ( eEvent ) {
726
727 case OMX_EventCmdComplete:
728 PRINT ("Component State Changed\n");
729 break;
730
731 case OMX_EventError:
732 if (nData1 == OMX_ErrorHardware){
733 printf("\n\nAPP:: ErrorNotification received: Error Num = %p Severity = %ld String = %s\n", (OMX_PTR)nData1, data2, (OMX_STRING)pEventData);
734 printf("\nAPP:: OMX_ErrorHardware. Deinitialization of the component....\n\n");
735 if(!bError) {
736 bError = OMX_TRUE;
737 write(Event_Pipe[1], &MyEvent, sizeof(JPEGE_EVENTPRIVATE));
738 }
739 }
740 else if(nData1 == OMX_ErrorResourcesPreempted) {
741 bPreempted = 1;
742 PRINT("APP:: OMX_ErrorResourcesPreempted !\n\n");
743 }
744 else if(nData1 == OMX_ErrorInvalidState) {
745 printf("\n\nAPP:: ErrorNotification received: Error Num = %p Severity = %ld String = %s\n", (OMX_PTR)nData1, data2, (OMX_STRING)pEventData);
746 printf("\nAPP:: Invalid state\n\n");
747 if(!bError) {
748 bError = OMX_TRUE;
749 write(Event_Pipe[1], &MyEvent, sizeof(JPEGE_EVENTPRIVATE));
750 }
751 }
752 else if(nData1 == OMX_ErrorPortUnpopulated) {
753 printf("APP:: OMX_ErrorPortUnpopulated\n");
754 bError = OMX_TRUE;
755 }
756 else if (nData1 == OMX_ErrorStreamCorrupt) {
757 printf("\n\nAPP:: ErrorNotification received: Error Num = %p Severity = %ld String = %s\n", (OMX_PTR)nData1, data2, (OMX_STRING)pEventData);
758 printf("%s: Stream Corrupt (%ld %s)\n",__FUNCTION__,data2,(char*)pEventData);
759 if(!bError) {
760 bError = OMX_TRUE;
761 write(Event_Pipe[1], &MyEvent, sizeof(JPEGE_EVENTPRIVATE));
762 }
763 }
764 else {
765 bError = OMX_TRUE;
766 DEINIT_FLAG = 1;
767 }
768
769 break;
770
771 case OMX_EventResourcesAcquired:
772 bPreempted = 0;
773 break;
774
775 case OMX_EventPortSettingsChanged:
776 case OMX_EventBufferFlag:
777 PRINT("Event Buffer Flag detected\n");
778 case OMX_EventMax:
779 case OMX_EventMark:
780 break;
781
782 default:
783 PRINT("ErrorNotification received: Error Num %p: String :%s\n", (OMX_PTR)nData1, (OMX_STRING)pEventData);
784 }
785
786 return OMX_ErrorNone;
787 }
788
789
FillBufferDone(OMX_HANDLETYPE hComponent,OMX_PTR ptr,OMX_BUFFERHEADERTYPE * pBuffHead)790 void FillBufferDone (OMX_HANDLETYPE hComponent, OMX_PTR ptr,
791 OMX_BUFFERHEADERTYPE* pBuffHead)
792 {
793 PRINT("Inside Test Application FillBufferDone function\n");
794 write(OpBuf_Pipe[1], &pBuffHead, sizeof(pBuffHead));
795 }
796
797
EmptyBufferDone(OMX_HANDLETYPE hComponent,OMX_PTR ptr,OMX_BUFFERHEADERTYPE * pBuffer)798 void EmptyBufferDone(OMX_HANDLETYPE hComponent, OMX_PTR ptr,
799 OMX_BUFFERHEADERTYPE* pBuffer)
800 {
801 PRINT("Inside Test Application EmptyBufferDone function\n");
802 write(IpBuf_Pipe[1], &pBuffer, sizeof(pBuffer));
803 }
804
805 #ifdef UNDER_CE
fill_data(OMX_BUFFERHEADERTYPE * pBufferPrivate,HANDLE fIn,int buffSize)806 int fill_data (OMX_BUFFERHEADERTYPE *pBufferPrivate, HANDLE fIn, int buffSize)
807 #else
808 int fill_data (OMX_BUFFERHEADERTYPE *pBuf, FILE *fIn, int buffSize)
809 #endif
810 {
811 int nRead;
812 OMX_U8 oneByte;
813 PRINT("Inside Test Application fill_data function\n");
814
815 #ifdef UNDER_CE
816 ReadFile(fIn, pBuf->pBuffer, lSize, &nRead, NULL);
817 #else
818 nRead = fread(pBuf->pBuffer,1, buffSize , fIn);
819 #endif
820
821 printf ("Buffer Size = %d. Read %d bytes from file. \n", (int) buffSize, (int)nRead);
822 pBuf->nFilledLen = nRead;
823
824 oneByte = fgetc(fIn);
825 if (feof(fIn)){
826 pBuf->nFlags = OMX_BUFFERFLAG_ENDOFFRAME;
827 PRINT("Read full file...\n");
828 rewind(fIn);
829 }
830 else{
831 ungetc(oneByte, fIn);
832 }
833
834 return nRead;
835 }
836
SetMarkers(OMX_HANDLETYPE pHandle,IMAGE_INFO * imageinfo,OMX_CONFIG_RECTTYPE sCrop,int nWidth,int nHeight)837 OMX_ERRORTYPE SetMarkers(OMX_HANDLETYPE pHandle, IMAGE_INFO *imageinfo, OMX_CONFIG_RECTTYPE sCrop, int nWidth, int nHeight) {
838
839 OMX_ERRORTYPE eError = OMX_ErrorNone;
840 OMX_INDEXTYPE nCustomIndex = OMX_IndexMax;
841
842 /* Set APP0 Marker config (JFIF) */
843 if (imageinfo->bAPP0) {
844
845 JPEG_APPTHUMB_MARKER sAPP0;
846
847 sAPP0.bMarkerEnabled = OMX_TRUE;
848
849 /* set JFIF marker buffer */
850 sAPP0.nMarkerSize = sizeof(APPLICATION0);
851 sAPP0.pMarkerBuffer = APPLICATION0;
852 sAPP0.nThumbnailWidth = imageinfo->nThumbnailWidth_app0;
853 sAPP0.nThumbnailHeight = imageinfo->nThumbnailHeight_app0;
854
855 eError = OMX_GetExtensionIndex(pHandle, "OMX.TI.JPEG.encoder.Config.APP0", (OMX_INDEXTYPE*)&nCustomIndex);
856 if ( eError != OMX_ErrorNone ) {
857 printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
858 eError = OMX_ErrorUndefined;
859 goto EXIT;
860 }
861 eError = OMX_SetConfig(pHandle, nCustomIndex, &sAPP0);
862 if ( eError != OMX_ErrorNone ) {
863 printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
864 eError = OMX_ErrorUndefined;
865 goto EXIT;
866 }
867
868 }
869
870 /* Set APP1 Marker config (EXIF) */
871 if (imageinfo->bAPP1) {
872
873 JPEG_APPTHUMB_MARKER sAPP1;
874
875 sAPP1.bMarkerEnabled = OMX_TRUE;
876
877 /* set JFIF marker buffer */
878 sAPP1.nThumbnailWidth = imageinfo->nThumbnailWidth_app1;
879 sAPP1.nThumbnailHeight = imageinfo->nThumbnailHeight_app1;
880
881 /* if thumbnail is set, use APPLICATION structure with thumbnail */
882 if(sAPP1.nThumbnailWidth > 0 && sAPP1.nThumbnailHeight > 0) {
883 sAPP1.nMarkerSize = sizeof(APPLICATION1_THUMB);
884 sAPP1.pMarkerBuffer = APPLICATION1_THUMB;
885 }
886 else {
887 sAPP1.nMarkerSize = sizeof(APPLICATION1_NOTHUMB);
888 sAPP1.pMarkerBuffer = APPLICATION1_NOTHUMB;
889 }
890
891 /*set crop */
892 if (sCrop.nWidth != 0)
893 {
894 sAPP1.pMarkerBuffer[152] = sCrop.nWidth & 0xFF;
895 sAPP1.pMarkerBuffer[153] = (sCrop.nWidth >> 8) & 0xFF;
896 }
897 else
898 {
899 sAPP1.pMarkerBuffer[152] = nWidth & 0xFF;
900 sAPP1.pMarkerBuffer[153] = (nWidth >> 8) & 0xFF;
901 }
902
903 if (sCrop.nHeight != 0)
904 {
905 sAPP1.pMarkerBuffer[164] = sCrop.nHeight;
906 sAPP1.pMarkerBuffer[165] = (sCrop.nHeight >> 8) & 0xFF;
907 }
908 else
909 {
910 sAPP1.pMarkerBuffer[164] = nHeight;
911 sAPP1.pMarkerBuffer[165] = (nHeight >> 8) & 0xFF;
912 }
913
914 eError = OMX_GetExtensionIndex(pHandle, "OMX.TI.JPEG.encoder.Config.APP1", (OMX_INDEXTYPE*)&nCustomIndex);
915 if ( eError != OMX_ErrorNone ) {
916 printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
917 eError = OMX_ErrorUndefined;
918 goto EXIT;
919 }
920 eError = OMX_SetConfig(pHandle, nCustomIndex, &sAPP1);
921 if ( eError != OMX_ErrorNone ) {
922 printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
923 eError = OMX_ErrorUndefined;
924 goto EXIT;
925 }
926 }
927
928 /* Set APP5 Marker config */
929 if (imageinfo->bAPP5) {
930
931 JPEG_APPTHUMB_MARKER sAPP5;
932
933 sAPP5.bMarkerEnabled = OMX_TRUE;
934
935 /* set JFIF marker buffer */
936 sAPP5.nMarkerSize = sizeof(APPLICATION5);
937 sAPP5.pMarkerBuffer = APPLICATION5;
938 sAPP5.nThumbnailWidth = imageinfo->nThumbnailWidth_app5;
939 sAPP5.nThumbnailHeight = imageinfo->nThumbnailHeight_app5;
940
941 eError = OMX_GetExtensionIndex(pHandle, "OMX.TI.JPEG.encoder.Config.APP5", (OMX_INDEXTYPE*)&nCustomIndex);
942 if ( eError != OMX_ErrorNone ) {
943 printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
944 eError = OMX_ErrorUndefined;
945 goto EXIT;
946 }
947 eError = OMX_SetConfig(pHandle, nCustomIndex, &sAPP5);
948 if ( eError != OMX_ErrorNone ) {
949 printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
950 eError = OMX_ErrorUndefined;
951 goto EXIT;
952 }
953
954 }
955
956 /* Set APP13 Marker config */
957 if (imageinfo->bAPP13) {
958
959 JPEG_APP13_MARKER sAPP13;
960
961 sAPP13.bMarkerEnabled = OMX_TRUE;
962
963 /* set JFIF marker buffer */
964 sAPP13.nMarkerSize = sizeof(APPLICATION13);
965 sAPP13.pMarkerBuffer = APPLICATION13;
966
967 eError = OMX_GetExtensionIndex(pHandle, "OMX.TI.JPEG.encoder.Config.APP13", (OMX_INDEXTYPE*)&nCustomIndex);
968 if ( eError != OMX_ErrorNone ) {
969 printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
970 eError = OMX_ErrorUndefined;
971 goto EXIT;
972 }
973 eError = OMX_SetConfig(pHandle, nCustomIndex, &sAPP13);
974 if ( eError != OMX_ErrorNone ) {
975 printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
976 eError = OMX_ErrorUndefined;
977 goto EXIT;
978 }
979 }
980
981 /* set comment marker */
982 if (imageinfo->nComment) {
983 eError = OMX_GetExtensionIndex(pHandle, "OMX.TI.JPEG.encoder.Config.CommentFlag", (OMX_INDEXTYPE*)&nCustomIndex);
984 if ( eError != OMX_ErrorNone ) {
985 printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
986 eError = OMX_ErrorUndefined;
987 goto EXIT;
988 }
989 eError = OMX_SetConfig(pHandle, nCustomIndex, &(imageinfo->nComment));
990 if ( eError != OMX_ErrorNone ) {
991 printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
992 eError = OMX_ErrorUndefined;
993 goto EXIT;
994 }
995
996 eError = OMX_GetExtensionIndex(pHandle, "OMX.TI.JPEG.encoder.Config.CommentString", (OMX_INDEXTYPE*)&nCustomIndex);
997 if ( eError != OMX_ErrorNone ) {
998 printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
999 eError = OMX_ErrorUndefined;
1000 goto EXIT;
1001 }
1002 eError = OMX_SetConfig(pHandle, nCustomIndex, imageinfo->pCommentString);
1003 if ( eError != OMX_ErrorNone ) {
1004 printf("%d::APP_Error at function call: %x\n", __LINE__, eError);
1005 eError = OMX_ErrorUndefined;
1006 goto EXIT;
1007 }
1008 }
1009
1010 EXIT:
1011 return eError;
1012 }
1013
PrintUsage(void)1014 void PrintUsage(void)
1015 {
1016 printf("\ni.. Input File\n");
1017 printf("o.. Output File\n");
1018 printf("w.. Width Of Image\n");
1019 printf("h.. Height Of Image\n");
1020 printf("f.. Input Of Image:\n 1.- YUV 420 Planer\n 2.- YUV 422 Interleaved UYVY\n 3.- 32 bit RAW (RGB32)\n 4.- 16 bit RAW (RGB16)\n 5.- YUV 422 Interleaved YUYV\n");
1021 printf("z.. 420p to 422i conversion before encode \n");
1022 printf("q.. Quality Factor Of Image: 1 to 100\n");
1023 printf("b.. Exit Buffer: 1 o 2\n");
1024 printf("c.. Marker Comment: The comment string length should be less than 255 characters\n");
1025 printf("j.. Marker APP0: Contain Information about JFIF\n");
1026 printf("e.. Marker APP1: Contain Information about EXIF\n");
1027 printf("d.. Marker APP5: Contain Miscellaneous Information\n");
1028 printf("m.. Marker APP13: Contain Miscellaneous Information\n");
1029 printf("x.. Width of Thumbnail of EXIF (default set to 88)\n");
1030 printf("y.. Height of Thumbnail of EXIF (default set to 72)\n");
1031 printf("s.. Width of Thumbnail of JFIF (default set to 88)\n");
1032 printf("k.. Height of Thumbnail of JFIF (default set to 72)\n");
1033 printf("n.. Width of Thumbnail of APP5 (default set to 88)\n");
1034 printf("p.. Height of Thumbnail of APP5 (default set to 72)\n");
1035 printf("t.. Type of Quantization Table \n\t 0.-Default Quantization Tables \n\t 1.-Custom Luma And Choma Tables\n");
1036 printf("u.. Type of Huffman Table \n\t 0.-Default Huffman Table \n\t 1.-Custom Huffman Table\n");
1037 printf("r.. No. of times to repeat\n");
1038 printf("v.. Crop width value\n");
1039 printf("l.. Crop height value\n");
1040
1041 printf("\na.. Prints this information\n");
1042 printf("\nExample: ./JPEGTestEnc_common -i patterns/JPGE_CONF_003.yuv -o output.jpg -w 176 -h 144 -f 2 -q 100 -b 1 -c JPEG -j -e -m -x 100 -y 100 -r 1\n\n");
1043 }
1044
1045
1046 #ifdef UNDER_CE
_tmain(int argc,TCHAR ** argv)1047 int _tmain(int argc, TCHAR **argv)
1048 #else
1049 int main(int argc, char** argv)
1050 #endif
1051 {
1052
1053 #ifndef UNDER_CE
1054 //mtrace();
1055 #endif
1056 OMX_HANDLETYPE pHandle;
1057 OMX_U32 AppData = 100;
1058
1059 OMX_CALLBACKTYPE JPEGCaBa = {(void *)EventHandler,
1060 (void*) EmptyBufferDone,
1061 (void*)FillBufferDone};
1062 int retval;
1063 int nWidth;
1064 int nHeight;
1065 int framesent = 0;
1066 int nRepeated = 0;
1067 int maxRepeat = 1;
1068 int inputformat;
1069 int qualityfactor;
1070 int buffertype;
1071 int bSetCustomHuffmanTable=0;
1072 int bSetCustomQuatizationTable=0;
1073 sigset_t set;
1074
1075 OMX_STATETYPE state;
1076 OMX_COMPONENTTYPE *pComponent;
1077 IMAGE_INFO* imageinfo = NULL;
1078 OMX_PORT_PARAM_TYPE* pPortParamType = NULL;
1079 OMX_IMAGE_PARAM_QFACTORTYPE* pQfactorType = NULL;
1080 JPEGENC_CUSTOM_HUFFMANTTABLETYPE *pHuffmanTable = NULL;
1081 OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE *pQuantizationTable = NULL;
1082 OMX_PARAM_PORTDEFINITIONTYPE* pInPortDef = NULL;
1083 OMX_PARAM_PORTDEFINITIONTYPE* pOutPortDef = NULL;
1084 OMX_CONFIG_RECTTYPE sCrop;
1085
1086 OMX_BOOL bConvertion_420pTo422i = OMX_FALSE;
1087
1088 #ifdef UNDER_CE
1089 TCHAR* szInFile = NULL;
1090 TCHAR* szOutFile = NULL;
1091 HANDLE fIn = NULL;
1092 HANDLE fOut = NULL;
1093 DWORD dwWritten;
1094 #else
1095 char* szInFile = NULL;
1096 char* szOutFile = NULL;
1097
1098 FILE* fIn = NULL;
1099 FILE* fOut = NULL;
1100 #endif
1101
1102 OMX_BUFFERHEADERTYPE* pInBuff[NUM_OF_BUFFERSJPEG];
1103 OMX_BUFFERHEADERTYPE* pOutBuff[NUM_OF_BUFFERSJPEG];
1104 int nCounter = 0;
1105 int fdmax;
1106 OMX_U8* pTemp;
1107 OMX_U8* pInBuffer[NUM_OF_BUFFERSJPEG];
1108 OMX_U8* pOutBuffer[NUM_OF_BUFFERSJPEG];
1109 OMX_BUFFERHEADERTYPE* pBuffer;
1110 OMX_BUFFERHEADERTYPE* pBuf;
1111 int nRead;
1112 int done;
1113 OMX_S32 sJPEGEnc_CompID = 300;
1114 int nIndex1= 0;
1115 int nIndex2 = 0;
1116 int nframerecieved = 0;
1117 int nMultFactor = 0;
1118 int nHeightNew, nWidthNew;
1119 OMX_INDEXTYPE nCustomIndex = OMX_IndexMax;
1120 OMX_ERRORTYPE error = OMX_ErrorNone;
1121
1122 #ifdef STRESS
1123 int multiload = 0;
1124 #endif
1125
1126 int next_option;
1127 const char* const short_options = "i:o:w:h:f:q:b:c:x:y:s:k:t:u:r:v:l:n:p:ajemdvlz";
1128 const struct option long_options[] =
1129 {
1130 { "InputFile",1, NULL, 'i' },
1131 { "OutputFile",1, NULL, 'o' },
1132 { "WidthImage",1, NULL, 'w' },
1133 { "HeightImage",1, NULL, 'h' },
1134 { "inputFormat",1, NULL, 'f' },
1135 { "QualityFactor",1, NULL, 'q' },
1136 { "Ext/IntBuffer",1, NULL, 'b' },
1137 { "MarkerComment",1, NULL, 'c' },
1138 { "EXIFwidthThumbnail",1, NULL, 'x' },
1139 { "EXIFheightThumbnail",1, NULL, 'y' },
1140 { "JFIFwidthThumbnail",1, NULL, 's' },
1141 { "JFIFheightThumbnail",1, NULL, 'k' },
1142 { "APP5heightThumbnail",1, NULL, 'p' },
1143 { "APP5widthThumbnail",1, NULL, 'n' },
1144 { "Repetition",1, NULL, 'r' },
1145 {"QuantizationTable",1,NULL,'t'},
1146 {"HuffmanTable",1,NULL,'u'},
1147 { "help", 0, NULL, 'a' },
1148 { "MarkerAPP0",0,NULL,'j'},
1149 { "MarkerAPP1",0,NULL,'e'},
1150 { "MarkerAPP13",0,NULL,'m'},
1151 { "MarkerAPP5",0,NULL,'d'},
1152 { "CroppedWidth",0,NULL,'v'},
1153 { "CroppedHeight",0,NULL,'l'},
1154 { "420pTo422iConversion",0,NULL,'z'},
1155 { NULL, 0, NULL, 0 }
1156 };
1157
1158 MALLOC(pPortParamType, OMX_PORT_PARAM_TYPE);
1159 MALLOC(pQfactorType, OMX_IMAGE_PARAM_QFACTORTYPE);
1160 MALLOC(pQuantizationTable,OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE);
1161 MALLOC(pHuffmanTable, JPEGENC_CUSTOM_HUFFMANTTABLETYPE);
1162 MALLOC(pInPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
1163 MALLOC(pOutPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
1164 MALLOC(imageinfo, IMAGE_INFO);
1165
1166 /* Setting up default parameters */
1167 szOutFile="output.jpg";
1168 nWidth=176;
1169 nHeight=144;
1170 inputformat=1;
1171 qualityfactor=100;
1172 buffertype=1;
1173
1174 imageinfo->nThumbnailWidth_app0 = 0;
1175 imageinfo->nThumbnailHeight_app0 = 0;
1176 imageinfo->nThumbnailWidth_app1 = 0;
1177 imageinfo->nThumbnailHeight_app1 = 0;
1178 imageinfo->nThumbnailWidth_app5 = 0;
1179 imageinfo->nThumbnailHeight_app5 = 0;
1180 imageinfo->nThumbnailWidth_app13 = 0;
1181 imageinfo->nThumbnailHeight_app13 = 0;
1182
1183 imageinfo->bAPP0 = OMX_FALSE;
1184 imageinfo->bAPP1 = OMX_FALSE;
1185 imageinfo->bAPP5 = OMX_FALSE;
1186 imageinfo->bAPP13 = OMX_FALSE;
1187 imageinfo->nComment = OMX_FALSE;
1188 imageinfo->pCommentString = NULL;
1189
1190 sCrop.nTop = 0;
1191 sCrop.nLeft = 0;
1192 sCrop.nWidth = 0;
1193 sCrop.nHeight = 0;
1194
1195 if (argc <= 1)
1196 {
1197 PrintUsage();
1198 return 0;
1199 }
1200
1201 do
1202 {
1203 next_option = getopt_long(argc, argv, short_options,long_options, NULL);
1204 switch(next_option)
1205 {
1206 case 'a':
1207 PrintUsage();
1208 return 0;
1209 break;
1210
1211 case 'i':
1212 szInFile=optarg;
1213 break;
1214
1215 case 'o':
1216 szOutFile=optarg;
1217 break;
1218
1219 case 'w':
1220 nWidth = atoi(optarg);
1221 break;
1222
1223 case 'h':
1224 nHeight=atoi(optarg);
1225 break;
1226
1227 case 'f':
1228 inputformat=atoi(optarg);
1229 break;
1230
1231 case 'z':
1232 bConvertion_420pTo422i = OMX_TRUE;
1233 PRINT("\n ********* bConvertion_420pTo422i is set to TRUE \n");
1234 break;
1235
1236 case 'q':
1237 qualityfactor=atoi(optarg);
1238 break;
1239
1240 case 'b':
1241 buffertype=atoi(optarg);
1242 break;
1243
1244 case 'c':
1245 imageinfo->nComment = 1;
1246 imageinfo->pCommentString = (char *)optarg;
1247 break;
1248
1249 /*EXIF */
1250
1251 case 'e':
1252 imageinfo->bAPP1 = OMX_TRUE;
1253 break;
1254
1255 case 'x':
1256 imageinfo->nThumbnailWidth_app1 = atoi(optarg);
1257 break;
1258
1259 case 'y':
1260 imageinfo->nThumbnailHeight_app1 = atoi(optarg);
1261 break;
1262
1263 /* JFIF */
1264 case 'j':
1265 imageinfo->bAPP0 = OMX_TRUE;
1266 break;
1267
1268 case 's':
1269 imageinfo->nThumbnailWidth_app0 = atoi(optarg);
1270 break;
1271
1272 case 'k':
1273 imageinfo->nThumbnailHeight_app0 = atoi(optarg);
1274 break;
1275
1276
1277 case 'n':
1278 imageinfo->nThumbnailWidth_app5 = atoi(optarg);
1279 break;
1280
1281 case 'p':
1282 imageinfo->nThumbnailHeight_app5 = atoi(optarg);
1283 break;
1284
1285 case 'm':
1286 imageinfo->bAPP13 = OMX_TRUE;
1287 break;
1288
1289 case 'd':
1290 imageinfo->bAPP5 = OMX_TRUE;
1291 break;
1292
1293 case 't':
1294 bSetCustomQuatizationTable=atoi(optarg);
1295 break;
1296
1297 case 'u':
1298 bSetCustomHuffmanTable=atoi(optarg);
1299 break;
1300
1301 case 'r':
1302 maxRepeat = atoi(optarg);
1303 break;
1304
1305 case 'v':
1306 sCrop.nWidth = atoi(optarg);
1307 break;
1308
1309 case 'l':
1310 sCrop.nHeight = atoi(optarg);
1311 break;
1312
1313 }
1314 }while (next_option != -1);
1315
1316 printf("\n------------------------------------------------\n");
1317 printf("OMX JPEG Encoder Test App built on " __DATE__ ":" __TIME__ "\n");
1318 printf("------------------------------------------------\n");
1319 printf("Output File Name is %s \n" , szOutFile);
1320
1321 #ifdef STRESS
1322
1323 for (multiload = 0; multiload < STRESSMULTILOAD; multiload ++) {
1324 printf("Stress Test: Iteration %d\n", multiload + 1);
1325 #endif
1326
1327
1328 #ifdef DSP_MMU_FAULT_HANDLING
1329 /* LOAD BASE IMAGE FIRST TIME */
1330 LoadBaseImage();
1331 #endif
1332
1333 error = TIOMX_Init();
1334 if ( error != OMX_ErrorNone ) {
1335 PRINT("Error returned by OMX_Init()\n");
1336 goto EXIT;
1337 }
1338
1339 printf("OMX_Init Successful!\n");
1340
1341 error = TIOMX_GetHandle(&pHandle,StrJpegEncoder,(void *)&AppData, &JPEGCaBa);
1342 if ( (error != OMX_ErrorNone) || (pHandle == NULL) ) {
1343 fprintf (stderr,"Error in Get Handle function\n");
1344 goto EXIT;
1345 }
1346
1347 #ifdef STRESS
1348 OMX_U8 i;
1349 for(i=0; i < NSTRESSCASES; i++) {
1350 printf("Stress test number %d\n",i);
1351 #endif
1352
1353 /* Create a pipe used to queue data from the callback. */
1354 retval = pipe(IpBuf_Pipe);
1355 if ( retval != 0 ) {
1356 fprintf(stderr, "Error:Fill Data Pipe failed to open\n");
1357 goto EXIT;
1358 }
1359
1360 retval = pipe(OpBuf_Pipe);
1361 if ( retval != 0 ) {
1362 fprintf(stderr, "Error:Empty Data Pipe failed to open\n");
1363 goto EXIT;
1364 }
1365
1366 retval = pipe(Event_Pipe);
1367 if ( retval != 0 ) {
1368 fprintf(stderr, "Error:Empty Data Pipe failed to open\n");
1369 goto EXIT;
1370 }
1371
1372 PRINT("Input/Output Pipes created\n");
1373
1374 /* save off the "max" of the handles for the selct statement */
1375 fdmax = maxint(IpBuf_Pipe[0], OpBuf_Pipe[0]);
1376 fdmax = maxint(Event_Pipe[0], fdmax);
1377
1378 #ifdef UNDER_CE
1379 fIn = CreateFile(szInFile, GENERIC_READ, 0,
1380 NULL,OPEN_EXISTING, 0, NULL);
1381 if (INVALID_HANDLE_VALUE == fIn)
1382 {
1383 PRINT("Error: failed to open the file %s for " \
1384 "reading\n", szInFile);
1385 goto EXIT;
1386 }
1387 #else
1388 fIn = fopen(szInFile, "r");
1389 if ( fIn == NULL ) {
1390 printf("Error: failed to open the file <%s> for reading\n",
1391 szInFile);
1392 goto EXIT;
1393 }
1394 PRINT(" File %s opened \n" , szInFile);
1395 #endif
1396
1397
1398 error = OMX_GetParameter(pHandle, OMX_IndexParamImageInit, pPortParamType);
1399 if ( error != OMX_ErrorNone ) {
1400 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1401 error = OMX_ErrorBadParameter;
1402 goto EXIT;
1403 }
1404
1405 nIndex1 = pPortParamType->nStartPortNumber;
1406 nIndex2 = nIndex1 + 1;
1407 pInPortDef->nPortIndex = nIndex1;
1408 error = OMX_GetParameter (pHandle, OMX_IndexParamPortDefinition, pInPortDef);
1409 if ( error != OMX_ErrorNone ) {
1410 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1411 error = OMX_ErrorBadParameter;
1412 goto EXIT;
1413 }
1414
1415 if (pInPortDef->eDir == nIndex1 ) {
1416 pInPortDef->nPortIndex = nIndex1;
1417 }
1418 else {
1419 pInPortDef->nPortIndex = nIndex2;
1420 }
1421
1422 /* Set the component's OMX_PARAM_PORTDEFINITIONTYPE structure (input) */
1423 pInPortDef->nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
1424 pInPortDef->nVersion.s.nVersionMajor = 0x1;
1425 pInPortDef->nVersion.s.nVersionMinor = 0x0;
1426 pInPortDef->nVersion.s.nRevision = 0x0;
1427 pInPortDef->nVersion.s.nStep = 0x0;
1428 pInPortDef->nPortIndex = 0x0;
1429 pInPortDef->eDir = OMX_DirInput;
1430 pInPortDef->nBufferCountActual = NUM_OF_BUFFERSJPEG;
1431 pInPortDef->nBufferCountMin = 1;
1432 pInPortDef->bEnabled = OMX_TRUE;
1433 pInPortDef->bPopulated = OMX_FALSE;
1434 pInPortDef->eDomain = OMX_PortDomainImage;
1435
1436 /* OMX_IMAGE_PORTDEFINITION values for input port */
1437 pInPortDef->format.image.cMIMEType = "JPEGENC";
1438 pInPortDef->format.image.pNativeRender = NULL;
1439 pInPortDef->format.image.nFrameWidth = nWidth;
1440 pInPortDef->format.image.nFrameHeight = nHeight;
1441 pInPortDef->format.image.nSliceHeight = -1;
1442 pInPortDef->format.image.bFlagErrorConcealment = OMX_FALSE;
1443
1444 if ( inputformat == 2) {
1445 pInPortDef->format.image.eColorFormat = OMX_COLOR_FormatCbYCrY;
1446 }
1447 else if ( inputformat == 3) {
1448 pInPortDef->format.image.eColorFormat = OMX_COLOR_Format32bitARGB8888;
1449 }
1450 else if (inputformat == 4) {
1451 pInPortDef->format.image.eColorFormat = OMX_COLOR_Format16bitRGB565;
1452 }
1453 else if ( inputformat == 5) {
1454 pInPortDef->format.image.eColorFormat = OMX_COLOR_FormatYCbYCr;
1455 }
1456 else {
1457 pInPortDef->format.image.eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar;
1458 }
1459
1460 pInPortDef->format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
1461
1462 nMultFactor = (nWidth + 16 - 1)/16;
1463 nWidthNew = (int)(nMultFactor) * 16;
1464
1465 nMultFactor = (nHeight + 16 - 1)/16;
1466 nHeightNew = (int)(nMultFactor) * 16;
1467
1468 if (inputformat == 1) {
1469 pInPortDef->nBufferSize = (nWidthNew * nHeightNew * 1.5);
1470 if (pInPortDef->nBufferSize < 1600) {
1471 pInPortDef->nBufferSize = 1600;
1472 }
1473 }
1474 else if(inputformat == 3) {
1475 pInPortDef->nBufferSize = (nWidthNew * nHeightNew * 4);
1476 }
1477 else {
1478 pInPortDef->nBufferSize = (nWidthNew * nHeightNew * 2);
1479 if (pInPortDef->nBufferSize < 400) {
1480 pInPortDef->nBufferSize = 400;
1481 }
1482 }
1483
1484
1485 error = OMX_SetParameter (pHandle, OMX_IndexParamPortDefinition, pInPortDef);
1486 if ( error != OMX_ErrorNone ) {
1487 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1488 error = OMX_ErrorBadParameter;
1489 goto EXIT;
1490 }
1491
1492 pOutPortDef->nPortIndex = nIndex2;
1493 error = OMX_GetParameter(pHandle, OMX_IndexParamPortDefinition, pOutPortDef);
1494 if ( error != OMX_ErrorNone ) {
1495 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1496 error = OMX_ErrorBadParameter;
1497 goto EXIT;
1498 }
1499 if (pOutPortDef->eDir == nIndex1 ) {
1500 pOutPortDef->nPortIndex = nIndex1;
1501 }
1502 else {
1503 pOutPortDef->nPortIndex = nIndex2;
1504 }
1505 /* Set the component's OMX_PARAM_PORTDEFINITIONTYPE structure (input) */
1506
1507 pOutPortDef->nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
1508 pOutPortDef->nVersion.s.nVersionMajor = 0x1;
1509 pOutPortDef->nVersion.s.nVersionMinor = 0x0;
1510 pOutPortDef->nVersion.s.nRevision = 0x0;
1511 pOutPortDef->nVersion.s.nStep = 0x0;
1512 pOutPortDef->nPortIndex = 0x1;
1513 pOutPortDef->eDir = OMX_DirInput;
1514 pOutPortDef->nBufferCountActual = NUM_OF_BUFFERSJPEG;
1515 pOutPortDef->nBufferCountMin = 1;
1516 pOutPortDef->bEnabled = OMX_TRUE;
1517 pOutPortDef->bPopulated = OMX_FALSE;
1518 pOutPortDef->eDomain = OMX_PortDomainImage;
1519
1520 /* OMX_IMAGE_PORTDEFINITION values for input port */
1521 pOutPortDef->format.image.cMIMEType = "JPEGENC";
1522 pOutPortDef->format.image.pNativeRender = NULL;
1523 pOutPortDef->format.image.nFrameWidth = nWidth;
1524 pOutPortDef->format.image.nFrameHeight = nHeight;
1525 pOutPortDef->format.image.nStride = -1;
1526 pOutPortDef->format.image.nSliceHeight = -1;
1527 pOutPortDef->format.image.bFlagErrorConcealment = OMX_FALSE;
1528
1529 /*Minimum buffer size requirement */
1530 pOutPortDef->nBufferSize = (nWidth*nHeight);
1531 if( qualityfactor < 10){
1532 pOutPortDef->nBufferSize /=10;
1533 }
1534 else if (qualityfactor <100){
1535 pOutPortDef->nBufferSize /= (100/qualityfactor);
1536 }
1537
1538 /*Adding memory to include Thumbnail, comments & markers information and header (depends on the app)*/
1539 pOutPortDef->nBufferSize += 12288;
1540
1541
1542 if ( inputformat == 2 || inputformat == 3 || inputformat == 4 ) {
1543 pOutPortDef->format.image.eColorFormat = OMX_COLOR_FormatCbYCrY;
1544 }
1545 else if ( inputformat == 1 && bConvertion_420pTo422i ) {
1546 pOutPortDef->format.image.eColorFormat = OMX_COLOR_FormatCbYCrY;
1547 }
1548 else {
1549 pOutPortDef->format.image.eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar;
1550 }
1551
1552 if (imageinfo->bAPP1) {
1553 pOutPortDef->format.image.eCompressionFormat = OMX_IMAGE_CodingEXIF;
1554 }
1555 else {
1556 pOutPortDef->format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG;
1557 }
1558
1559 error = OMX_SetParameter (pHandle, OMX_IndexParamPortDefinition, pOutPortDef);
1560 if ( error != OMX_ErrorNone ) {
1561 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1562 error = OMX_ErrorBadParameter;
1563 goto EXIT;
1564 }
1565
1566 pComponent = (OMX_COMPONENTTYPE *)pHandle;
1567
1568 error = OMX_SetConfig(pHandle, OMX_IndexConfigCommonInputCrop, &sCrop);
1569 if ( error != OMX_ErrorNone ) {
1570 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1571 error = OMX_ErrorBadParameter;
1572 goto EXIT;
1573 }
1574
1575 error = OMX_SetConfig(pHandle, OMX_IndexCustomColorFormatConvertion_420pTo422i, &bConvertion_420pTo422i);
1576 if ( error != OMX_ErrorNone ) {
1577 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1578 error = OMX_ErrorBadParameter;
1579 goto EXIT;
1580 }
1581
1582 if (bSetCustomQuatizationTable){
1583
1584 pQuantizationTable->eQuantizationTable = OMX_IMAGE_QuantizationTableLuma;
1585 error = OMX_GetParameter(pHandle, OMX_IndexParamQuantizationTable, pQuantizationTable);
1586 if ( error != OMX_ErrorNone ) {
1587 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1588 error = OMX_ErrorBadParameter;
1589 goto EXIT;
1590 }
1591
1592 pTemp = (OMX_U8*)memcpy(pQuantizationTable->nQuantizationMatrix, CustomLumaQuantizationTable, sizeof(CustomLumaQuantizationTable));
1593 if(pTemp == NULL){
1594 printf("%d::APP_Error at function call\n", __LINE__);
1595 error = OMX_ErrorUndefined;
1596 goto EXIT;
1597 }
1598
1599 error = OMX_SetParameter(pHandle, OMX_IndexParamQuantizationTable, pQuantizationTable);
1600 if ( error != OMX_ErrorNone ) {
1601 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1602 error = OMX_ErrorBadParameter;
1603 goto EXIT;
1604 }
1605
1606 pQuantizationTable->eQuantizationTable = OMX_IMAGE_QuantizationTableChroma;
1607 error = OMX_GetParameter(pHandle, OMX_IndexParamQuantizationTable, pQuantizationTable);
1608 if ( error != OMX_ErrorNone ) {
1609 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1610 error = OMX_ErrorBadParameter;
1611 goto EXIT;
1612 }
1613
1614 pTemp = (OMX_U8*)memcpy(pQuantizationTable->nQuantizationMatrix, CustomChromaQuantizationTable, sizeof(CustomChromaQuantizationTable));
1615 if(pTemp == NULL){
1616 error = OMX_ErrorUndefined;
1617 goto EXIT;
1618 }
1619
1620 error = OMX_SetParameter(pHandle, OMX_IndexParamQuantizationTable, pQuantizationTable);
1621 if ( error != OMX_ErrorNone ) {
1622 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1623 error = OMX_ErrorBadParameter;
1624 goto EXIT;
1625 }
1626 }
1627
1628 if (bSetCustomHuffmanTable){
1629
1630 error = OMX_GetExtensionIndex(pHandle, "OMX.TI.JPEG.encoder.Config.HuffmanTable", (OMX_INDEXTYPE*)&nCustomIndex);
1631 if ( error != OMX_ErrorNone ) {
1632 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1633 error = OMX_ErrorBadParameter;
1634 goto EXIT;
1635 }
1636
1637 error = OMX_GetParameter(pHandle, nCustomIndex, pHuffmanTable);
1638 if ( error != OMX_ErrorNone ) {
1639 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1640 error = OMX_ErrorBadParameter;
1641 goto EXIT;
1642 }
1643
1644 pTemp = (OMX_U8*)memcpy(&(pHuffmanTable->sHuffmanTable), &CustomHuffmanTable, sizeof(CustomHuffmanTable));
1645 if(pTemp == NULL){
1646 error = OMX_ErrorUndefined;
1647 goto EXIT;
1648 }
1649
1650 error = OMX_SetParameter(pHandle, nCustomIndex, pHuffmanTable);
1651 if ( error != OMX_ErrorNone ) {
1652 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1653 error = OMX_ErrorBadParameter;
1654 goto EXIT;
1655 }
1656 }
1657
1658
1659 pComponent = (OMX_COMPONENTTYPE *)pHandle;
1660 error = OMX_SendCommand(pHandle, OMX_CommandStateSet, OMX_StateIdle ,NULL);
1661 if ( error != OMX_ErrorNone ) {
1662 fprintf (stderr,"Error from SendCommand-Idle(Init) State function\n");
1663 goto EXIT;
1664 }
1665
1666 if (buffertype == 1) {
1667
1668 for (nCounter = 0; nCounter < NUM_OF_BUFFERSJPEG; nCounter++) {
1669 pTemp=(OMX_U8*)malloc(pInPortDef->nBufferSize+256);
1670 if(pTemp == NULL){
1671 error = OMX_ErrorInsufficientResources;
1672 goto EXIT;
1673 }
1674 pTemp+= 128;
1675 pInBuffer[nCounter] = pTemp;
1676 pTemp = NULL;
1677
1678 pTemp= (OMX_U8*)malloc(pOutPortDef->nBufferSize+256);
1679 if(pTemp == NULL){
1680 error = OMX_ErrorInsufficientResources;
1681 goto EXIT;
1682 }
1683 pTemp+= 128;
1684 pOutBuffer[nCounter] = pTemp;
1685 }
1686
1687 for (nCounter = 0; nCounter < NUM_OF_BUFFERSJPEG; nCounter++) {
1688 error = OMX_UseBuffer(pHandle, &pInBuff[nCounter], nIndex1, (void*)&sJPEGEnc_CompID, pInPortDef->nBufferSize,pInBuffer[nCounter]);
1689 }
1690 for (nCounter = 0; nCounter < NUM_OF_BUFFERSJPEG; nCounter++) {
1691 error = OMX_UseBuffer(pHandle, &pOutBuff[nCounter], nIndex2, (void*)&sJPEGEnc_CompID, pOutPortDef->nBufferSize,pOutBuffer[nCounter]);
1692 }
1693 }
1694
1695 if (buffertype == 2) {
1696 for (nCounter = 0; nCounter < NUM_OF_BUFFERSJPEG; nCounter++) {
1697 error = OMX_AllocateBuffer(pHandle, &pInBuff[nCounter], nIndex1, (void *)&sJPEGEnc_CompID, pInPortDef->nBufferSize);
1698 }
1699 for (nCounter = 0; nCounter < NUM_OF_BUFFERSJPEG; nCounter++) {
1700 error = OMX_AllocateBuffer(pHandle, &pOutBuff[nCounter], nIndex2, (void *)&sJPEGEnc_CompID, pOutPortDef->nBufferSize);
1701 }
1702 }
1703
1704 /* set markers */
1705 error = SetMarkers(pHandle, imageinfo, sCrop, nWidth, nHeight);
1706 if ( error != OMX_ErrorNone ) {
1707 fprintf (stderr,"Error from SetMarkers() function\n");
1708 goto EXIT;
1709 }
1710
1711 /**
1712 * wait for initialization to complete (as indicated by the statechange
1713 * callback saying that component has been loaded (and is therefore
1714 * initialized. Note that you should probably handle GUI events
1715 * in the WaitForState method.
1716 **/
1717
1718 PRINT("Waiting for state Idle\n");
1719 error = WaitForState(pHandle, OMX_StateIdle);
1720 if ( error != OMX_ErrorNone ) {
1721 PRINT("Error: JpegEncoder->WaitForState has timed out or failed %X\n",
1722 error);
1723 goto EXIT;
1724 }
1725
1726 pQfactorType->nSize = sizeof(OMX_IMAGE_PARAM_QFACTORTYPE);
1727 pQfactorType->nQFactor = (OMX_U32) qualityfactor;
1728 pQfactorType->nVersion.s.nVersionMajor = 0x1;
1729 pQfactorType->nVersion.s.nVersionMinor = 0x0;
1730 pQfactorType->nVersion.s.nRevision = 0x0;
1731 pQfactorType->nVersion.s.nStep = 0x0;
1732 pQfactorType->nPortIndex = 0x0;
1733
1734 error = OMX_GetExtensionIndex(pHandle, "OMX.TI.JPEG.encoder.Config.QFactor", (OMX_INDEXTYPE*)&nCustomIndex);
1735 if ( error != OMX_ErrorNone ) {
1736 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1737 goto EXIT;
1738 }
1739 error = OMX_SetConfig (pHandle, nCustomIndex, pQfactorType);
1740 if ( error != OMX_ErrorNone ) {
1741 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1742 goto EXIT;
1743 }
1744
1745
1746 /**
1747 * Open the file of data to be rendered. Since this is a just sample
1748 * application, the data is "rendered" to a test mixer. So, the test
1749 * file better contain data that can be printed to the terminal w/o
1750 * problems or you will not be a happy camper.
1751 **/
1752 PRINT("Opening output jpg file\n");
1753 #ifdef UNDER_CE
1754 fOut = CreateFile(szOutFile, GENERIC_WRITE, 0,
1755 NULL,CREATE_ALWAYS, 0, NULL);
1756 if (INVALID_HANDLE_VALUE == fOut){
1757 PRINT("Error: failed to open the file <%s> for writing\n",
1758 szOutFile);
1759 goto EXIT;
1760 }
1761 #else
1762 fOut = fopen(szOutFile, "w");
1763 if ( fOut == NULL ) {
1764 PRINT("Error: failed to open the file <%s> for writing\n",
1765 szOutFile);
1766 goto EXIT;
1767 }
1768 #endif
1769
1770 error = OMX_SendCommand(pHandle,OMX_CommandStateSet, OMX_StateExecuting, NULL);
1771 if ( error != OMX_ErrorNone ) {
1772 fprintf (stderr,"Error from SendCommand-Executing State function\n");
1773 goto EXIT;
1774 }
1775 pComponent = (OMX_COMPONENTTYPE *)pHandle;
1776
1777 /**
1778 * wait for startup to complete (as indicated by the statechange
1779 * callback saying that component has been loaded (and is therefore
1780 * initialized. Note that you should probably handle GUI events
1781 * in the WaitForState method.
1782 **/
1783
1784 PRINT("Waiting for OMX_StateExcecuting\n");
1785 error = WaitForState(pHandle, OMX_StateExecuting);
1786 if ( error != OMX_ErrorNone ) {
1787 PRINT("Error: JpegEncoder->WaitForState has timed out or failed %X\n", error);
1788 goto EXIT;
1789 }
1790
1791 #if 0
1792 if (imageinfo->nDRI) {
1793 error = OMX_GetExtensionIndex(pHandle, "OMX.TI.JPEG.encoder.Config.DRI", (OMX_INDEXTYPE*)&nCustomIndex);
1794 if ( error != OMX_ErrorNone ) {
1795 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1796 goto EXIT;
1797 }
1798 error = OMX_SetConfig(pHandle, nCustomIndex, &(imageinfo->nDRI));
1799 if ( error != OMX_ErrorNone ) {
1800 printf("%d::APP_Error at function call: %x\n", __LINE__, error);
1801 goto EXIT;
1802 }
1803 }
1804 #endif
1805
1806 /** Handle the component's requests for data until we run out of data. Do this
1807 * in a way that will allow the UI to continue to run (if there is a UI, which
1808 * this sample application does NOT have)
1809 **/
1810
1811 done = 0;
1812 pComponent->GetState(pHandle, &state);
1813 PRINT("Error is %d , cur state is %d ",error, state);
1814
1815
1816 for (nCounter =0; nCounter<1 /*NUM_OF_BUFFERSJPEG*/; nCounter++) {
1817 nRead = fill_data(pInBuff[nCounter], fIn,pInPortDef->nBufferSize);
1818 pComponent->FillThisBuffer(pHandle, pOutBuff[nCounter]);
1819 pComponent->EmptyThisBuffer(pHandle, pInBuff[nCounter]);
1820 framesent++;
1821 PRINT("Sent Frame # %d\n", framesent);
1822 if (pInBuff[nCounter]->nFlags == OMX_BUFFERFLAG_ENDOFFRAME)
1823 break;
1824 }
1825
1826 while ((error == OMX_ErrorNone) &&
1827 (state != OMX_StateIdle)) {
1828
1829 if (bPreempted)
1830 {
1831 PRINT("Preempted - Forced tp Idle State - Waiting for OMX_StateIdle\n");
1832 error = WaitForState(pHandle, OMX_StateIdle);
1833 if ( error != OMX_ErrorNone ) {
1834 PRINT("Error: JpegEncoder->WaitForState has timed out or failed %X", error);
1835 goto EXIT;
1836 }
1837 break;
1838 }
1839
1840 fd_set rfds;
1841 sigemptyset(&set);
1842 sigaddset(&set,SIGALRM);
1843
1844 FD_ZERO(&rfds);
1845 FD_SET(IpBuf_Pipe[0], &rfds);
1846 FD_SET(OpBuf_Pipe[0], &rfds);
1847 FD_SET(Event_Pipe[0], &rfds);
1848 retval = pselect(fdmax+1, &rfds, NULL, NULL, NULL,&set);
1849 if ( retval == -1 ) {
1850 #ifndef UNDER_CE
1851 perror("select()");
1852 #endif
1853 fprintf (stderr, " : Error \n");
1854 break;
1855 }
1856 else if ( retval == 0 ) {
1857 PRINT("App Timeout !!!!!!!!!!!\n");
1858 }
1859
1860 /**
1861 * If FD_ISSET for Event_Pipe, there is an event remaining on the pipe. Read it
1862 * and get act accordingly to the event.
1863 **/
1864 if ( FD_ISSET(Event_Pipe[0], &rfds)) {
1865
1866 JPEGE_EVENTPRIVATE EventPrivate;
1867 read(Event_Pipe[0], &EventPrivate, sizeof(JPEGE_EVENTPRIVATE));
1868
1869 switch(EventPrivate.eEvent) {
1870 case OMX_EventError:
1871 if(bError) {
1872 error = WaitForState(pHandle, OMX_StateInvalid);
1873 if (error != OMX_ErrorNone) {
1874 printf("APP:: Error: JpegEncoder->WaitForState has timed out or failed %X\n", error);
1875 goto EXIT;
1876 }
1877 printf("APP:: Component is in Invalid state now.\n");
1878 goto EXIT;
1879 }
1880 break;
1881
1882 case OMX_EventBufferFlag:
1883 printf("APP:: EOS flag received\n");
1884 break;
1885
1886 default:
1887 printf("APP:: Non-error event rised. Event -> 0x%x\n", EventPrivate.eEvent);
1888 break;
1889 }
1890 }
1891
1892 /**
1893 * If FD_ISSET for IpBuf_Pipe, then there is an empty buffer available on the pipe. Read it
1894 * from the pipe, then re-fill the buffer and send it back.
1895 **/
1896 if ( FD_ISSET(IpBuf_Pipe[0], &rfds) && !DEINIT_FLAG ) {
1897
1898 /*read buffer */
1899 read(IpBuf_Pipe[0], &pBuffer, sizeof(pBuffer));
1900
1901 /* re-fill this buffer with data from JPEG file */
1902 nRead = fill_data(pBuffer, fIn,pInPortDef->nBufferSize);
1903
1904 /* call EmptyThisBuffer (send buffer back to component */
1905 OMX_EmptyThisBuffer(pHandle, pBuffer);
1906
1907 /*increment count */
1908 framesent++;
1909 PRINT("Sent Frame # %d\n", framesent);
1910 }
1911
1912 /**
1913 * If FD_ISSET for OpBuf_Pipe, then there is a filled buffer available on the pipe. Read it
1914 * and get the buffer data out, write it to a file and then re-empty the buffer and send
1915 * the buffer back to the component.
1916 **/
1917 if (FD_ISSET(OpBuf_Pipe[0], &rfds)) {
1918
1919 /* read buffer */
1920 read(OpBuf_Pipe[0], &pBuf, sizeof(pBuf));
1921
1922 /* write data to a file, buffer is assumed to be emptied after this*/
1923 #ifdef UNDER_CE
1924 WriteFile(fOut, pBuf->pBuffer, pBuf->nFilledLen, &dwWritten, NULL);
1925 #else
1926 printf("APP:: Write into file %lu bytes (%d)\n",pBuf->nFilledLen, nframerecieved);
1927 fwrite(pBuf->pBuffer, 1, (int)pBuf->nFilledLen, fOut);
1928 fflush(fOut);
1929 #endif
1930 /*increment count and validate for limits; call FillThisBuffer */
1931 nframerecieved++;
1932 nRepeated++;
1933 PRINT("\n%d***************%d***************%d***************%d***************%d\n", nRepeated, nRepeated, nRepeated, nRepeated, nRepeated);
1934 if (nRepeated >= maxRepeat) {
1935 DEINIT_FLAG = 1;
1936 }
1937 else {
1938 PRINT("Sending another output buffer\n");
1939 pComponent->FillThisBuffer(pHandle,pBuf);
1940 }
1941 }
1942
1943 if (DEINIT_FLAG == 1) {
1944 done = 1;
1945 pHandle = (OMX_HANDLETYPE *) pComponent;
1946 error = OMX_SendCommand(pHandle,OMX_CommandStateSet, OMX_StateIdle, NULL);
1947 if ( error != OMX_ErrorNone ) {
1948 fprintf (stderr,"APP:: Error from SendCommand-Idle(Stop) State function\n");
1949 goto EXIT;
1950 }
1951
1952 PRINT("Waiting for OMX_StateIdle\n");
1953 error = WaitForState(pHandle, OMX_StateIdle);
1954 if ( error != OMX_ErrorNone ) {
1955 PRINT("Error: JpegEncoder->WaitForState has timed out %X", error);
1956 goto EXIT;
1957 }
1958
1959 error = OMX_SendCommand(pHandle, OMX_CommandPortDisable, 0, NULL);
1960 if ( error != OMX_ErrorNone ) {
1961 PRINT("Error from SendCommand-PortDisable function\n");
1962 goto EXIT;
1963 }
1964 }
1965
1966 if (done == 1) {
1967 error = pComponent->GetState(pHandle, &state);
1968 if ( error != OMX_ErrorNone ){
1969 fprintf(stderr, "Warning: JpegEncoder->JPEGENC_GetState has returned status %X\n", error);
1970 goto EXIT;
1971 }
1972 PRINT("After GetState() in while loop.\n");
1973 }
1974 }
1975
1976
1977
1978
1979 #ifdef STRESS
1980 }
1981 #endif
1982
1983 printf("\nTest Completed Successfully! Deinitializing ... \n\n");
1984
1985 EXIT:
1986
1987 printf("\nClosing application...\n");
1988
1989 /**
1990 * Freeing memory
1991 **/
1992
1993 /*close handles */
1994 #ifdef UNDER_CE
1995 CloseHandle(fOut);
1996 CloseHandle(fIn);
1997 #else
1998 fclose(fOut);
1999 rewind (fIn);
2000 fclose(fIn);
2001 #endif
2002
2003 PRINT("Freeing memory from test app\n");
2004 FREE(pPortParamType);
2005 FREE(pQfactorType);
2006 FREE(pInPortDef);
2007 FREE(pOutPortDef);
2008 FREE(imageinfo);
2009 FREE(pQuantizationTable);
2010 FREE(pHuffmanTable);
2011
2012 if( error != OMX_ErrorNone){
2013 if (buffertype == 1) {
2014 for (nCounter = 0; nCounter < NUM_OF_BUFFERSJPEG; nCounter++) {
2015 pOutBuffer[nCounter]-=128;
2016 pInBuffer[nCounter]-=128;
2017 FREE(pOutBuffer[nCounter]);
2018 FREE(pInBuffer[nCounter]);
2019 }
2020 }
2021 for (nCounter = 0; nCounter < NUM_OF_BUFFERSJPEG; nCounter++) {
2022 error = OMX_FreeBuffer(pHandle, nIndex1, pInBuff[nCounter]);
2023 if ( (error != OMX_ErrorNone) ) {
2024 printf ("Error in OMX_FreeBuffer: %d\n", __LINE__);
2025 }
2026 error = OMX_FreeBuffer(pHandle, nIndex2, pOutBuff[nCounter]);
2027 if ( (error != OMX_ErrorNone) ) {
2028 printf ("Error in OMX_FreeBuffer: %d\n", __LINE__);
2029 }
2030 }
2031 }
2032
2033 error = TIOMX_FreeHandle(pHandle);
2034 if ( (error != OMX_ErrorNone) ) {
2035 printf ("Error in Free Handle function\n");
2036 }
2037
2038 #ifdef DSP_MMU_FAULT_HANDLING
2039
2040 if(bError) {
2041 LoadBaseImage();
2042 }
2043
2044 #endif
2045
2046 error = TIOMX_Deinit();
2047 if ( error != OMX_ErrorNone ) {
2048 printf("Error returned by OMX_DeInit()\n");
2049 }
2050
2051 #ifdef STRESS
2052
2053 } /* end of multiload loop */
2054
2055 #endif
2056
2057 #ifndef UNDER_CE
2058 //muntrace();
2059 #endif
2060 PRINT ("Free Handle returned Successfully = %x\n",error);
2061 return error;
2062 }
2063
2064 #ifdef DSP_MMU_FAULT_HANDLING
2065
LoadBaseImage()2066 int LoadBaseImage() {
2067 unsigned int uProcId = 0; /* default proc ID is 0. */
2068 unsigned int index = 0;
2069
2070 struct DSP_PROCESSORINFO dspInfo;
2071 DSP_HPROCESSOR hProc;
2072 DSP_STATUS status = DSP_SOK;
2073 unsigned int numProcs;
2074 char* argv[2];
2075
2076 argv[0] = "/lib/dsp/baseimage.dof";
2077
2078 status = (DBAPI)DspManager_Open(0, NULL);
2079 if (DSP_FAILED(status)) {
2080 printf("DSPManager_Open failed \n");
2081 return -1;
2082 }
2083 while (DSP_SUCCEEDED(DSPManager_EnumProcessorInfo(index,&dspInfo,
2084 (unsigned int)sizeof(struct DSP_PROCESSORINFO),&numProcs))) {
2085 if ((dspInfo.uProcessorType == DSPTYPE_55) ||
2086 (dspInfo.uProcessorType == DSPTYPE_64)) {
2087 uProcId = index;
2088 status = DSP_SOK;
2089 break;
2090 }
2091 index++;
2092 }
2093 status = DSPProcessor_Attach(uProcId, NULL, &hProc);
2094 if (DSP_SUCCEEDED(status)) {
2095 status = DSPProcessor_Stop(hProc);
2096 if (DSP_SUCCEEDED(status)) {
2097 status = DSPProcessor_Load(hProc,1,(const char **)argv,NULL);
2098 if (DSP_SUCCEEDED(status)) {
2099 status = DSPProcessor_Start(hProc);
2100 if (DSP_SUCCEEDED(status)) {
2101 }
2102 else {
2103 }
2104 }
2105 else {
2106 }
2107 DSPProcessor_Detach(hProc);
2108 }
2109 else {
2110 }
2111 }
2112 else {
2113 }
2114 fprintf(stderr,"Baseimage Loaded\n");
2115
2116 return 0;
2117 }
2118 #endif
2119
