00001
00034 #include "omxaudiodectest.h"
00035
00036 #define MP3_TYPE_SEL 1
00037 #define VORBIS_TYPE_SEL 2
00038 #define AAC_TYPE_SEL 3
00039 #define G726_TYPE_SEL 4
00040 #define COMPONENT_NAME_BASE "OMX.st.audio_decoder"
00041 #define BASE_ROLE "audio_decoder.ogg"
00042 #define COMPONENT_NAME_BASE_LEN 20
00043 #define SINK_NAME "OMX.st.alsa.alsasink"
00044 #define FILE_READER "OMX.st.audio_filereader"
00045 #define AUDIO_EFFECT "OMX.st.volume.component"
00046 #define extradata_size 1024
00047
00048 appPrivateType* appPriv;
00049
00050 OMX_BUFFERHEADERTYPE *outBufferFileRead1, *outBufferFileRead2;
00051 OMX_BUFFERHEADERTYPE *inBufferAudioDec1, *inBufferAudioDec2,*outBufferAudioDec1, *outBufferAudioDec2;
00052 OMX_BUFFERHEADERTYPE *inBufferVolume1, *inBufferVolume2,*outBufferVolume1, *outBufferVolume2;
00053 OMX_BUFFERHEADERTYPE *inBufferSink1, *inBufferSink2;
00054 int buffer_in_size = BUFFER_IN_SIZE;
00055 int buffer_out_size = BUFFER_OUT_SIZE;
00056 static OMX_BOOL bEOS=OMX_FALSE;
00057
00058 OMX_CALLBACKTYPE audiodeccallbacks = {
00059 .EventHandler = audiodecEventHandler,
00060 .EmptyBufferDone = audiodecEmptyBufferDone,
00061 .FillBufferDone = audiodecFillBufferDone
00062 };
00063
00064 OMX_CALLBACKTYPE audiosinkcallbacks = {
00065 .EventHandler = audiosinkEventHandler,
00066 .EmptyBufferDone = audiosinkEmptyBufferDone,
00067 .FillBufferDone = NULL
00068 };
00069
00070 OMX_CALLBACKTYPE filereadercallbacks = {
00071 .EventHandler = filereaderEventHandler,
00072 .EmptyBufferDone = NULL,
00073 .FillBufferDone = filereaderFillBufferDone
00074 };
00075
00076 OMX_CALLBACKTYPE volumecallbacks = {
00077 .EventHandler = volumeEventHandler,
00078 .EmptyBufferDone = volumeEmptyBufferDone,
00079 .FillBufferDone = volumeFillBufferDone
00080 };
00081
00082 FILE *fd ,*outfile;
00083 char *input_file, *output_file;
00084 int selectedType = 0;
00085
00086 static void setHeader(OMX_PTR header, OMX_U32 size) {
00087 OMX_VERSIONTYPE* ver = (OMX_VERSIONTYPE*)(header + sizeof(OMX_U32));
00088 *((OMX_U32*)header) = size;
00089
00090 ver->s.nVersionMajor = VERSIONMAJOR;
00091 ver->s.nVersionMinor = VERSIONMINOR;
00092 ver->s.nRevision = VERSIONREVISION;
00093 ver->s.nStep = VERSIONSTEP;
00094 }
00095
00096
00097 void display_help() {
00098 printf("\n");
00099 printf("Usage: omxaudiodectest [-o outfile] [-stmdgh] filename\n");
00100 printf("\n");
00101 printf(" -o outfile: If this option is specified, the decoded stream is written to outfile\n");
00102 printf(" This option can't be used with '-t' \n");
00103 printf(" -s single_ogg: Use the single role Ogg Vorbis decoder instead of the default one. Can't be used with -m or .mp3 file\n");
00104 printf(" -t: The audio decoder is tunneled with the ALSA sink\n");
00105 printf(" -m: For MP3 decoding use the mad library. Can't be used with -s or .ogg file\n");
00106 printf(" -d: If no output is specified, and no playback is specified,\n");
00107 printf(" this flag activated the print of the stream directly on stdout\n");
00108 printf(" -f: Use filereader with mad\n");
00109 printf(" -g: Gain of the audio sink[0...100]\n");
00110 printf(" -h: Displays this help\n");
00111 printf("\n");
00112 exit(1);
00113 }
00114
00115 OMX_ERRORTYPE test_OMX_ComponentNameEnum() {
00116 char * name;
00117 int index;
00118
00119 OMX_ERRORTYPE err = OMX_ErrorNone;
00120
00121 DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s\n",__func__);
00122 name = malloc(OMX_MAX_STRINGNAME_SIZE);
00123 index = 0;
00124 while(1) {
00125 err = OMX_ComponentNameEnum (name, OMX_MAX_STRINGNAME_SIZE, index);
00126 if ((name != NULL) && (err == OMX_ErrorNone)) {
00127 DEBUG(DEFAULT_MESSAGES, "component %i is %s\n",index, name);
00128 } else break;
00129 if (err != OMX_ErrorNone) break;
00130 index++;
00131 }
00132 free(name);
00133 name = NULL;
00134 DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00135 return err;
00136 }
00137
00138 OMX_ERRORTYPE test_OMX_RoleEnum(OMX_STRING component_name) {
00139 OMX_U32 no_of_roles;
00140 OMX_U8 **string_of_roles;
00141 OMX_ERRORTYPE err = OMX_ErrorNone;
00142 int index;
00143
00144 DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s\n",__func__);
00145 DEBUG(DEB_LEV_SIMPLE_SEQ, "Getting roles of %s. Passing Null first...\n", component_name);
00146 err = OMX_GetRolesOfComponent(component_name, &no_of_roles, NULL);
00147 if (err != OMX_ErrorNone) {
00148 DEBUG(DEB_LEV_ERR, "Not able to retrieve the number of roles of the given component\n");
00149 DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00150 return err;
00151 }
00152 DEBUG(DEFAULT_MESSAGES, "The number of roles for the component %s is: %i\n", component_name, (int)no_of_roles);
00153
00154 if(no_of_roles == 0) {
00155 DEBUG(DEB_LEV_ERR, "The Number or roles is 0.\nThe component selected is not correct for the purpose of this test.\nExiting...\n");
00156 err = OMX_ErrorInvalidComponentName;
00157 } else {
00158 string_of_roles = (OMX_U8**)malloc(no_of_roles * sizeof(OMX_STRING));
00159 for (index = 0; index<no_of_roles; index++) {
00160 *(string_of_roles + index) = (OMX_U8 *)malloc(no_of_roles*OMX_MAX_STRINGNAME_SIZE);
00161 }
00162 DEBUG(DEB_LEV_SIMPLE_SEQ, "...then buffers\n");
00163
00164 err = OMX_GetRolesOfComponent(component_name, &no_of_roles, string_of_roles);
00165 if (err != OMX_ErrorNone) {
00166 DEBUG(DEB_LEV_ERR, "Not able to retrieve the roles of the given component\n");
00167 } else if(string_of_roles != NULL) {
00168 for (index = 0; index < no_of_roles; index++) {
00169 DEBUG(DEFAULT_MESSAGES, "The role %i for the component: %s \n", (index + 1), *(string_of_roles+index));
00170 }
00171 } else {
00172 DEBUG(DEB_LEV_ERR, "role string is NULL!!! Exiting...\n");
00173 err = OMX_ErrorInvalidComponentName;
00174 }
00175 for (index = 0; index<no_of_roles; index++) {
00176 free(*(string_of_roles + index));
00177 }
00178 free(string_of_roles);
00179 }
00180 DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00181 return err;
00182 }
00183
00184 OMX_ERRORTYPE test_OMX_ComponentEnumByRole(OMX_STRING role_name) {
00185 OMX_U32 no_of_comp_per_role;
00186 OMX_U8 **string_of_comp_per_role;
00187 OMX_ERRORTYPE err;
00188 int index;
00189
00190 DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s\n",__func__);
00191
00192 DEBUG(DEFAULT_MESSAGES, "Getting number of components per role for %s\n", role_name);
00193
00194 err = OMX_GetComponentsOfRole(role_name, &no_of_comp_per_role, NULL);
00195 if (err != OMX_ErrorNone) {
00196 DEBUG(DEB_LEV_ERR, "Not able to retrieve the number of components of a given role\n");
00197 DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00198 return err;
00199 }
00200 DEBUG(DEFAULT_MESSAGES, "Number of components per role for %s is %i\n", role_name, (int)no_of_comp_per_role);
00201
00202 string_of_comp_per_role = (OMX_U8**)malloc(no_of_comp_per_role * sizeof(OMX_STRING));
00203 for (index = 0; index<no_of_comp_per_role; index++) {
00204 string_of_comp_per_role[index] = malloc(OMX_MAX_STRINGNAME_SIZE);
00205 }
00206
00207 err = OMX_GetComponentsOfRole(role_name, &no_of_comp_per_role, string_of_comp_per_role);
00208 if (err != OMX_ErrorNone) {
00209 DEBUG(DEB_LEV_ERR, "Not able to retrieve the components of a given role\n");
00210 DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00211 for (index = 0; index<no_of_comp_per_role; index++) {
00212 if(string_of_comp_per_role[index]) {
00213 free(string_of_comp_per_role[index]);
00214 string_of_comp_per_role[index] = NULL;
00215 }
00216 }
00217
00218 if(string_of_comp_per_role) {
00219 free(string_of_comp_per_role);
00220 string_of_comp_per_role = NULL;
00221 }
00222 return err;
00223 }
00224
00225 DEBUG(DEFAULT_MESSAGES, " The components are:\n");
00226 for (index = 0; index < no_of_comp_per_role; index++) {
00227 DEBUG(DEFAULT_MESSAGES, "%s\n", string_of_comp_per_role[index]);
00228 }
00229 for (index = 0; index<no_of_comp_per_role; index++) {
00230 if(string_of_comp_per_role[index]) {
00231 free(string_of_comp_per_role[index]);
00232 string_of_comp_per_role[index] = NULL;
00233 }
00234 }
00235
00236 if(string_of_comp_per_role) {
00237 free(string_of_comp_per_role);
00238 string_of_comp_per_role = NULL;
00239 }
00240 DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result OMX_ErrorNone\n",__func__);
00241 return OMX_ErrorNone;
00242 }
00243
00244 OMX_ERRORTYPE test_OpenClose(OMX_STRING component_name) {
00245 OMX_ERRORTYPE err = OMX_ErrorNone;
00246
00247 DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s\n",__func__);
00248 err = OMX_GetHandle(&appPriv->audiodechandle, component_name, NULL , &audiodeccallbacks);
00249 if(err != OMX_ErrorNone) {
00250 DEBUG(DEB_LEV_ERR, "No component found\n");
00251 } else {
00252 err = OMX_FreeHandle(appPriv->audiodechandle);
00253 if(err != OMX_ErrorNone) {
00254 DEBUG(DEB_LEV_ERR, "In %s err %08x in Free Handle\n",__func__,err);
00255 }
00256 }
00257 DEBUG(DEFAULT_MESSAGES, "GENERAL TEST %s result %i\n",__func__, err);
00258 return err;
00259 }
00260
00261 int flagIsOutputExpected;
00262 int flagSetupTunnel;
00263 int flagPlaybackOn;
00264 int flagOutputReceived;
00265 int flagInputReceived;
00266 int flagIsMadRequested;
00267 int flagIsMadUsingFileReader;
00268 int flagDirect;
00269 int flagSingleOGGSelected;
00270 int flagUsingFFMpeg;
00271 int flagIsGain;
00272
00273
00274 int main(int argc, char** argv) {
00275 int argn_dec;
00276 char *temp = NULL;
00277 OMX_ERRORTYPE err;
00278 OMX_INDEXTYPE eIndexParamFilename;
00279 OMX_STRING full_component_name;
00280 int index;
00281 int data_read;
00282 int gain=-1;
00283 OMX_AUDIO_CONFIG_VOLUMETYPE sVolume;
00284
00285 if(argc < 2){
00286 display_help();
00287 } else {
00288 flagIsOutputExpected = 0;
00289 flagSetupTunnel = 0;
00290 flagPlaybackOn = 1;
00291 flagOutputReceived = 0;
00292 flagInputReceived = 0;
00293 flagIsMadRequested = 0;
00294 flagIsMadUsingFileReader = 0;
00295 flagDirect = 0;
00296 flagSingleOGGSelected = 0;
00297 flagUsingFFMpeg = 1;
00298 flagIsGain = 0;
00299
00300 argn_dec = 1;
00301 while (argn_dec<argc) {
00302 if (*(argv[argn_dec]) =='-') {
00303 if (flagIsOutputExpected) {
00304 display_help();
00305 }
00306 switch (*(argv[argn_dec]+1)) {
00307 case 'h':
00308 display_help();
00309 break;
00310 case 's':
00311 flagSingleOGGSelected = 1;
00312 flagUsingFFMpeg = 0;
00313 break;
00314 case 't':
00315 flagSetupTunnel = 1;
00316 break;
00317 case 'o':
00318 flagIsOutputExpected = 1;
00319 flagPlaybackOn = 0;
00320 break;
00321 case 'm':
00322 flagIsMadRequested = 1;
00323 flagUsingFFMpeg = 0;
00324 break;
00325 case 'f':
00326 flagIsMadUsingFileReader = 1;
00327 break;
00328 case 'd':
00329 flagDirect = 1;
00330 flagPlaybackOn = 0;
00331 break;
00332 case 'g':
00333 flagIsGain = 1;
00334 break;
00335 default:
00336 display_help();
00337 }
00338 } else {
00339 if (flagIsGain) {
00340 gain = (int)atoi(argv[argn_dec]);
00341 flagIsGain = 0;
00342 if(gain > 100) {
00343 DEBUG(DEFAULT_MESSAGES, "Gain should be between [0..100]\n");
00344 gain = 100;
00345 }
00346 } else if (flagIsOutputExpected) {
00347 output_file = malloc(strlen(argv[argn_dec]) + 1);
00348 strcpy(output_file,argv[argn_dec]);
00349 flagIsOutputExpected = 0;
00350 flagOutputReceived = 1;
00351 } else {
00352 input_file = malloc(strlen(argv[argn_dec]) + 1);
00353 strcpy(input_file,argv[argn_dec]);
00354 flagInputReceived = 1;
00355 }
00356 }
00357 argn_dec++;
00358 }
00359 if (flagSetupTunnel) {
00360 if(flagOutputReceived) {
00361 DEBUG(DEFAULT_MESSAGES, "-o Option Ignored. No FILE output will be produced.\n");
00362 flagOutputReceived = 0;
00363 }
00364 flagPlaybackOn = 1;
00365 }
00366 if (!flagInputReceived) {
00367 display_help();
00368 }
00369 DEBUG(DEFAULT_MESSAGES, "Options selected:\n");
00370 DEBUG(DEFAULT_MESSAGES, "Decode file %s", input_file);
00371 DEBUG(DEFAULT_MESSAGES, " to ");
00372 if (flagPlaybackOn) {
00373 DEBUG(DEFAULT_MESSAGES, " ALSA sink");
00374 if (flagSetupTunnel) {
00375 DEBUG(DEFAULT_MESSAGES, " with tunneling\n");
00376 } else {
00377 DEBUG(DEFAULT_MESSAGES, " without tunneling\n");
00378 }
00379 } else {
00380 if (flagOutputReceived) {
00381 DEBUG(DEFAULT_MESSAGES, " %s\n", output_file);
00382 }
00383 }
00384 }
00385 index = 0;
00386 while(*(input_file+index) != '\0') {
00387 index++;
00388 }
00389 DEBUG(DEFAULT_MESSAGES, "Format selected ");
00390 if (*(input_file+index -1) == '3') {
00391 selectedType = MP3_TYPE_SEL;
00392 DEBUG(DEFAULT_MESSAGES, "MP3\n");
00393 if(flagSingleOGGSelected) {
00394 DEBUG(DEB_LEV_ERR, "ERROR:Wrong Format(OGG Single) Selected\n");
00395 display_help();
00396 }
00397 } else if(*(input_file+index -1) == 'g') {
00398 selectedType = VORBIS_TYPE_SEL;
00399 DEBUG(DEFAULT_MESSAGES, "VORBIS\n");
00400 if(flagIsMadRequested) {
00401 DEBUG(DEB_LEV_ERR, "ERROR:Wrong Format(MAD) Selected\n");
00402 display_help();
00403 }
00404 } else if(*(input_file+index -1) == 'c') {
00405 selectedType = AAC_TYPE_SEL;
00406 DEBUG(DEFAULT_MESSAGES, "AAC\n");
00407 if(flagIsMadRequested || flagSingleOGGSelected) {
00408 DEBUG(DEB_LEV_ERR, "ERROR:Wrong Format(MAD/VORBIS) Selected\n");
00409 display_help();
00410 }
00411 } else if(*(input_file+index -1) == '6') {
00412 selectedType = G726_TYPE_SEL;
00413 DEBUG(DEFAULT_MESSAGES, "G726\n");
00414 if(flagIsMadRequested || flagSingleOGGSelected) {
00415 DEBUG(DEB_LEV_ERR, "ERROR:Wrong Format(MAD/VORBIS) Selected\n");
00416 display_help();
00417 }
00418 flagUsingFFMpeg = 0;
00419 } else {
00420 DEBUG(DEB_LEV_ERR, "The input audio format is not supported - exiting\n");
00421 exit(1);
00422 }
00423
00424
00425 if (flagOutputReceived) {
00426 outfile = fopen(output_file,"wb");
00427 if(outfile == NULL) {
00428 DEBUG(DEB_LEV_ERR, "Error at opening the output file");
00429 exit(1);
00430 }
00431 }
00432
00433 if(!flagUsingFFMpeg && !flagIsMadUsingFileReader) {
00434 fd = fopen(input_file, "rb");
00435 if(fd == NULL) {
00436 DEBUG(DEB_LEV_ERR, "Error in opening input file %s\n", input_file);
00437 exit(1);
00438 }
00439 }
00440
00442 appPriv = malloc(sizeof(appPrivateType));
00443 appPriv->filereaderEventSem = malloc(sizeof(tsem_t));
00444 appPriv->decoderEventSem = malloc(sizeof(tsem_t));
00445 appPriv->eofSem = malloc(sizeof(tsem_t));
00446 if (flagPlaybackOn) {
00447 appPriv->sinkEventSem = malloc(sizeof(tsem_t));
00448 tsem_init(appPriv->sinkEventSem, 0);
00449 appPriv->volumeEventSem = malloc(sizeof(tsem_t));
00450 tsem_init(appPriv->volumeEventSem, 0);
00451 }
00452 tsem_init(appPriv->filereaderEventSem, 0);
00453 tsem_init(appPriv->decoderEventSem, 0);
00454 tsem_init(appPriv->eofSem, 0);
00455
00457 err = OMX_Init();
00458 if (err != OMX_ErrorNone) {
00459 DEBUG(DEB_LEV_ERR, "The OpenMAX core can not be initialized. Exiting...\n");
00460 exit(1);
00461 }
00462
00463 DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00464 test_OMX_ComponentNameEnum();
00465 DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00466 test_OMX_RoleEnum(COMPONENT_NAME_BASE);
00467 DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00468 test_OMX_ComponentEnumByRole(BASE_ROLE);
00469 DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00470 test_OpenClose(COMPONENT_NAME_BASE);
00471 DEBUG(DEFAULT_MESSAGES, "------------------------------------\n");
00472
00473 full_component_name = (OMX_STRING) malloc(OMX_MAX_STRINGNAME_SIZE);
00474 strcpy(full_component_name, COMPONENT_NAME_BASE);
00475 if(selectedType == MP3_TYPE_SEL) {
00476 strcpy(full_component_name+COMPONENT_NAME_BASE_LEN, ".mp3");
00477 if (flagIsMadRequested) {
00478 strcpy(full_component_name+COMPONENT_NAME_BASE_LEN+4, ".mad");
00479 }
00480 } else if (selectedType == VORBIS_TYPE_SEL) {
00481 strcpy(full_component_name+COMPONENT_NAME_BASE_LEN, ".ogg");
00482 if (flagSingleOGGSelected) {
00483 strcpy(full_component_name+COMPONENT_NAME_BASE_LEN+4, ".single");
00484 }
00485 } else if (selectedType == AAC_TYPE_SEL) {
00486 strcpy(full_component_name+COMPONENT_NAME_BASE_LEN, ".aac");
00487 } else if (selectedType == G726_TYPE_SEL) {
00488 strcpy(full_component_name+COMPONENT_NAME_BASE_LEN, ".g726");
00489 }
00490
00491 if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00492 DEBUG(DEB_LEV_SIMPLE_SEQ, "Using File Reader\n");
00494 err = OMX_GetHandle(&appPriv->filereaderhandle, FILE_READER, NULL , &filereadercallbacks);
00495 if(err != OMX_ErrorNone) {
00496 DEBUG(DEB_LEV_ERR, "FileReader Component Not Found\n");
00497 exit(1);
00498 }
00499 }
00500
00502 DEBUG(DEB_LEV_SIMPLE_SEQ, "Getting Audio %s Decoder Handle\n",full_component_name);
00503 err = OMX_GetHandle(&appPriv->audiodechandle, full_component_name, NULL , &audiodeccallbacks);
00504 if(err != OMX_ErrorNone) {
00505 DEBUG(DEB_LEV_ERR, "Audio Decoder Component Not Found\n");
00506 exit(1);
00507 }
00508 DEBUG(DEFAULT_MESSAGES, "Component %s opened\n", full_component_name);
00509 if (flagPlaybackOn) {
00510 err = OMX_GetHandle(&appPriv->audiosinkhandle, SINK_NAME, NULL , &audiosinkcallbacks);
00511 if(err != OMX_ErrorNone){
00512 DEBUG(DEB_LEV_ERR, "No sink found. Exiting...\n");
00513 exit(1);
00514 }
00515 DEBUG(DEFAULT_MESSAGES, "Getting Handle for Component %s\n", AUDIO_EFFECT);
00516 err = OMX_GetHandle(&appPriv->volumehandle, AUDIO_EFFECT, NULL , &volumecallbacks);
00517 if(err != OMX_ErrorNone){
00518 DEBUG(DEB_LEV_ERR, "No Volume Component found. Exiting...\n");
00519 exit(1);
00520 }
00521
00522 if((gain >= 0) && (gain <100)) {
00523 err = OMX_GetConfig(appPriv->volumehandle, OMX_IndexConfigAudioVolume, &sVolume);
00524 if(err!=OMX_ErrorNone) {
00525 DEBUG(DEB_LEV_ERR,"Error %08x In OMX_GetConfig 0 \n",err);
00526 }
00527 sVolume.sVolume.nValue = gain;
00528 DEBUG(DEFAULT_MESSAGES, "Setting Gain %d \n", gain);
00529 err = OMX_SetConfig(appPriv->volumehandle, OMX_IndexConfigAudioVolume, &sVolume);
00530 if(err!=OMX_ErrorNone) {
00531 DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetConfig 0 \n",err);
00532 }
00533 }
00534
00535 err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandPortDisable, 1, NULL);
00536 if(err != OMX_ErrorNone) {
00537 DEBUG(DEB_LEV_ERR,"audiosink clock port disable failed err=%x \n",err);
00538 exit(1);
00539 }
00540 tsem_down(appPriv->sinkEventSem);
00541 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Audio Sink Clock Port Disabled\n", __func__);
00542 }
00543
00544 if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00546 err = OMX_GetExtensionIndex(appPriv->filereaderhandle,"OMX.ST.index.param.filereader.inputfilename",&eIndexParamFilename);
00547 if(err != OMX_ErrorNone) {
00548 DEBUG(DEB_LEV_ERR,"\n error in get extension index\n");
00549 exit(1);
00550 } else {
00551 DEBUG(DEB_LEV_SIMPLE_SEQ,"FileName Param index : %x \n",eIndexParamFilename);
00552 temp = malloc(25);
00553 OMX_GetParameter(appPriv->filereaderhandle,eIndexParamFilename,temp);
00554 err = OMX_SetParameter(appPriv->filereaderhandle,eIndexParamFilename,input_file);
00555 if(err != OMX_ErrorNone) {
00556 DEBUG(DEB_LEV_ERR,"\n error in input audio format - exiting\n");
00557 exit(1);
00558 }
00559 }
00560 }
00561
00562 if (flagSetupTunnel) {
00563 DEBUG(DEB_LEV_SIMPLE_SEQ, "Setting up Tunnel\n");
00564 if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00565 err = OMX_SetupTunnel(appPriv->filereaderhandle, 0, appPriv->audiodechandle, 0);
00566 if(err != OMX_ErrorNone) {
00567 DEBUG(DEB_LEV_ERR, "Set up Tunnel Failed\n");
00568 exit(1);
00569 }
00570 }
00571 err = OMX_SetupTunnel(appPriv->audiodechandle, 1, appPriv->volumehandle, 0);
00572 if(err != OMX_ErrorNone) {
00573 DEBUG(DEB_LEV_ERR, "Set up Tunnel Failed\n");
00574 exit(1);
00575 }
00576 err = OMX_SetupTunnel(appPriv->volumehandle, 1, appPriv->audiosinkhandle, 0);
00577 if(err != OMX_ErrorNone) {
00578 DEBUG(DEB_LEV_ERR, "Set up Tunnel Failed\n");
00579 exit(1);
00580 }
00581 DEBUG(DEB_LEV_SIMPLE_SEQ, "Set up Tunnel Completed\n");
00582 }
00583
00584 if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00586 OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00587 }
00588
00589 if (flagSetupTunnel) {
00590 DEBUG(DEB_LEV_SIMPLE_SEQ, "Send Command Idle to Audio Dec\n");
00591
00592 err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00593 if (flagPlaybackOn) {
00594 DEBUG(DEB_LEV_SIMPLE_SEQ, "Send Command Idle to Audio Sink\n");
00595 err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00596 err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00597 }
00598 if( !flagUsingFFMpeg && !flagIsMadUsingFileReader) {
00599 err = OMX_AllocateBuffer(appPriv->audiodechandle, &inBufferAudioDec1, 0, NULL, buffer_in_size);
00600 if(err != OMX_ErrorNone) {
00601 DEBUG(DEB_LEV_ERR, "Unable to allocate buffer\n");
00602 exit(1);
00603 }
00604 err = OMX_AllocateBuffer(appPriv->audiodechandle, &inBufferAudioDec2, 0, NULL, buffer_in_size);
00605 if(err != OMX_ErrorNone) {
00606 DEBUG(DEB_LEV_ERR, "Unable to allocate buffer\n");
00607 exit(1);
00608 }
00609 }
00610 }
00611
00612 if (!flagSetupTunnel && ( flagUsingFFMpeg || flagIsMadUsingFileReader)) {
00613 outBufferFileRead1 = outBufferFileRead2 = NULL;
00617 err = OMX_AllocateBuffer(appPriv->filereaderhandle, &outBufferFileRead1, 0, NULL, buffer_out_size);
00618 if(err != OMX_ErrorNone) {
00619 DEBUG(DEB_LEV_ERR, "Unable to allocate buffer 1 in file read\n");
00620 exit(1);
00621 }
00622 err = OMX_AllocateBuffer(appPriv->filereaderhandle, &outBufferFileRead2, 0, NULL, buffer_out_size);
00623 if(err != OMX_ErrorNone) {
00624 DEBUG(DEB_LEV_ERR, "Unable to allocate buffer 2 in file read\n");
00625 exit(1);
00626 }
00627 }
00628 if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00629
00630 tsem_down(appPriv->filereaderEventSem);
00631 DEBUG(DEFAULT_MESSAGES,"File reader idle state \n");
00632 }
00633
00634 if (flagSetupTunnel) {
00635 tsem_down(appPriv->decoderEventSem);
00636 if (flagPlaybackOn) {
00637 tsem_down(appPriv->volumeEventSem);
00638 tsem_down(appPriv->sinkEventSem);
00639 }
00640 }
00641
00642 if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00643 err = OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
00644 if(err != OMX_ErrorNone) {
00645 DEBUG(DEB_LEV_ERR,"file reader state executing failed\n");
00646 exit(1);
00647 }
00648
00649 tsem_down(appPriv->filereaderEventSem);
00650 DEBUG(DEFAULT_MESSAGES,"File reader executing state \n");
00651
00652
00653
00654 tsem_down(appPriv->filereaderEventSem);
00655 DEBUG(DEFAULT_MESSAGES,"File reader Port Settings Changed event \n");
00656 }
00657
00658
00659 if (!flagSetupTunnel) {
00660 err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00661
00665 if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00666 err = OMX_UseBuffer(appPriv->audiodechandle, &inBufferAudioDec1, 0, NULL, buffer_out_size, outBufferFileRead1->pBuffer);
00667 if(err != OMX_ErrorNone) {
00668 DEBUG(DEB_LEV_ERR, "Unable to use the file read comp allocate buffer\n");
00669 exit(1);
00670 }
00671 err = OMX_UseBuffer(appPriv->audiodechandle, &inBufferAudioDec2, 0, NULL, buffer_out_size, outBufferFileRead2->pBuffer);
00672 if(err != OMX_ErrorNone) {
00673 DEBUG(DEB_LEV_ERR, "Unable to use the file read comp allocate buffer\n");
00674 exit(1);
00675 }
00676 }
00677 else {
00678 err = OMX_AllocateBuffer(appPriv->audiodechandle, &inBufferAudioDec1, 0, NULL, buffer_in_size);
00679 if(err != OMX_ErrorNone) {
00680 DEBUG(DEB_LEV_ERR, "Unable to allocate buffer\n");
00681 exit(1);
00682 }
00683 err = OMX_AllocateBuffer(appPriv->audiodechandle, &inBufferAudioDec2, 0, NULL, buffer_in_size);
00684 if(err != OMX_ErrorNone) {
00685 DEBUG(DEB_LEV_ERR, "Unable to allocate buffer\n");
00686 exit(1);
00687 }
00688 }
00689
00690 err = OMX_AllocateBuffer(appPriv->audiodechandle, &outBufferAudioDec1, 1, NULL, buffer_out_size);
00691 if(err != OMX_ErrorNone) {
00692 DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in audio dec\n");
00693 exit(1);
00694 }
00695 err = OMX_AllocateBuffer(appPriv->audiodechandle, &outBufferAudioDec2, 1, NULL, buffer_out_size);
00696 if(err != OMX_ErrorNone) {
00697 DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in audio dec\n");
00698 exit(1);
00699 }
00700
00701 tsem_down(appPriv->decoderEventSem);
00702 }
00703
00704
00705 if ((flagPlaybackOn) && (!flagSetupTunnel)) {
00706 err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00707
00708 err = OMX_UseBuffer(appPriv->volumehandle, &inBufferVolume1, 0, NULL, buffer_out_size, outBufferAudioDec1->pBuffer);
00709 if(err != OMX_ErrorNone) {
00710 DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
00711 exit(1);
00712 }
00713 err = OMX_UseBuffer(appPriv->volumehandle, &inBufferVolume2, 0, NULL, buffer_out_size, outBufferAudioDec2->pBuffer);
00714 if(err != OMX_ErrorNone) {
00715 DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
00716 exit(1);
00717 }
00718
00719 err = OMX_AllocateBuffer(appPriv->volumehandle, &outBufferVolume1, 1, NULL, buffer_out_size);
00720 if(err != OMX_ErrorNone) {
00721 DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in volume 1\n");
00722 exit(1);
00723 }
00724 err = OMX_AllocateBuffer(appPriv->volumehandle, &outBufferVolume2, 1, NULL, buffer_out_size);
00725 if(err != OMX_ErrorNone) {
00726 DEBUG(DEB_LEV_ERR, "Unable to allocate buffer in volume 2\n");
00727 exit(1);
00728 }
00729
00730 if (flagPlaybackOn) {
00731 tsem_down(appPriv->volumeEventSem);
00732 DEBUG(DEB_LEV_SIMPLE_SEQ,"volume state idle\n");
00733 }
00734
00735 err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00736
00737 err = OMX_UseBuffer(appPriv->audiosinkhandle, &inBufferSink1, 0, NULL, buffer_out_size, outBufferVolume1->pBuffer);
00738 if(err != OMX_ErrorNone) {
00739 DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
00740 exit(1);
00741 }
00742 err = OMX_UseBuffer(appPriv->audiosinkhandle, &inBufferSink2, 0, NULL, buffer_out_size, outBufferVolume2->pBuffer);
00743 if(err != OMX_ErrorNone) {
00744 DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
00745 exit(1);
00746 }
00747 if (flagPlaybackOn) {
00748 tsem_down(appPriv->sinkEventSem);
00749 DEBUG(DEB_LEV_SIMPLE_SEQ,"audio sink state idle\n");
00750 }
00751 }
00752
00753 err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
00754 if(err != OMX_ErrorNone) {
00755 DEBUG(DEB_LEV_ERR,"audio decoder state executing failed\n");
00756 exit(1);
00757 }
00758
00759 tsem_down(appPriv->decoderEventSem);
00760 if (flagPlaybackOn) {
00761 err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
00762 if(err != OMX_ErrorNone) {
00763 DEBUG(DEB_LEV_ERR,"volume state executing failed\n");
00764 exit(1);
00765 }
00766 DEBUG(DEB_LEV_SIMPLE_SEQ,"waiting for volume state executing\n");
00767 tsem_down(appPriv->volumeEventSem);
00768
00769 DEBUG(DEB_LEV_SIMPLE_SEQ,"sending audio sink state executing\n");
00770 err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
00771 if(err != OMX_ErrorNone) {
00772 DEBUG(DEB_LEV_ERR,"audio sink state executing failed\n");
00773 exit(1);
00774 }
00775 DEBUG(DEB_LEV_SIMPLE_SEQ,"waiting for audio sink state executing\n");
00776 tsem_down(appPriv->sinkEventSem);
00777 DEBUG(DEB_LEV_SIMPLE_SEQ, "audio sink state executing successful\n");
00778 }
00779
00780 DEBUG(DEB_LEV_SIMPLE_SEQ,"All Component state changed to Executing\n");
00781 if (!flagSetupTunnel && (flagUsingFFMpeg || flagIsMadUsingFileReader)) {
00782 err = OMX_FillThisBuffer(appPriv->filereaderhandle, outBufferFileRead1);
00783 if(err != OMX_ErrorNone) {
00784 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer File Reader\n", __func__,err);
00785 exit(1);
00786 }
00787 DEBUG(DEB_LEV_PARAMS, "Fill reader second buffer %x\n", (int)outBufferFileRead1);
00788 err = OMX_FillThisBuffer(appPriv->filereaderhandle, outBufferFileRead2);
00789 if(err != OMX_ErrorNone) {
00790 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer File Reader\n", __func__,err);
00791 exit(1);
00792 }
00793 }
00794
00795 if (!flagSetupTunnel && flagPlaybackOn) {
00796 err = OMX_FillThisBuffer(appPriv->volumehandle, outBufferVolume1);
00797 if(err != OMX_ErrorNone) {
00798 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Audio Dec\n", __func__,err);
00799 exit(1);
00800 }
00801 DEBUG(DEB_LEV_PARAMS, "Fill decoder second buffer %x\n", (int)outBufferVolume2);
00802 err = OMX_FillThisBuffer(appPriv->volumehandle, outBufferVolume2);
00803 if(err != OMX_ErrorNone) {
00804 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Audio Dec\n", __func__,err);
00805 exit(1);
00806 }
00807 }
00808
00809 if(!flagUsingFFMpeg && !flagIsMadUsingFileReader) {
00810 data_read = fread(inBufferAudioDec1->pBuffer, 1, buffer_in_size, fd);
00811 inBufferAudioDec1->nFilledLen = data_read;
00812 inBufferAudioDec1->nOffset = 0;
00813
00814 data_read = fread(inBufferAudioDec2->pBuffer, 1, buffer_in_size, fd);
00815 inBufferAudioDec2->nFilledLen = data_read;
00816 inBufferAudioDec2->nOffset = 0;
00817
00818 DEBUG(DEB_LEV_PARAMS, "Empty first buffer %x\n", (int)inBufferAudioDec1);
00819 err = OMX_EmptyThisBuffer(appPriv->audiodechandle, inBufferAudioDec1);
00820 DEBUG(DEB_LEV_PARAMS, "Empty second buffer %x\n", (int)inBufferAudioDec2);
00821 err = OMX_EmptyThisBuffer(appPriv->audiodechandle, inBufferAudioDec2);
00822 }
00823
00824 if (!flagSetupTunnel) {
00825 err = OMX_FillThisBuffer(appPriv->audiodechandle, outBufferAudioDec1);
00826 if(err != OMX_ErrorNone) {
00827 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Audio Dec\n", __func__,err);
00828 exit(1);
00829 }
00830 DEBUG(DEB_LEV_PARAMS, "Fill decoder second buffer %x\n", (int)outBufferAudioDec2);
00831 err = OMX_FillThisBuffer(appPriv->audiodechandle, outBufferAudioDec2);
00832 if(err != OMX_ErrorNone) {
00833 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer Audio Dec\n", __func__,err);
00834 exit(1);
00835 }
00836 }
00837
00838 DEBUG(DEFAULT_MESSAGES,"Waiting for EOS = %d\n",appPriv->eofSem->semval);
00839
00840 tsem_down(appPriv->eofSem);
00841
00842 DEBUG(DEFAULT_MESSAGES,"Received EOS \n");
00843
00844 DEBUG(DEFAULT_MESSAGES, "The execution of the decoding process is terminated\n");
00845 if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00846 err = OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00847 }
00848 err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00849 if (flagPlaybackOn) {
00850 err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00851 err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
00852 }
00853 if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00854 tsem_down(appPriv->filereaderEventSem);
00855 DEBUG(DEFAULT_MESSAGES,"File reader idle state \n");
00856 }
00857 tsem_down(appPriv->decoderEventSem);
00858 if (flagPlaybackOn) {
00859 tsem_down(appPriv->volumeEventSem);
00860 tsem_down(appPriv->sinkEventSem);
00861 }
00862
00863 DEBUG(DEFAULT_MESSAGES, "All component Transitioned to Idle\n");
00864
00865 if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00866 err = OMX_SendCommand(appPriv->filereaderhandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
00867 }
00868 err = OMX_SendCommand(appPriv->audiodechandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
00869 if (flagPlaybackOn) {
00870 err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
00871 err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
00872 }
00873
00874 DEBUG(DEFAULT_MESSAGES, "Audio dec to loaded\n");
00875
00876
00877 if (!flagSetupTunnel || (!flagUsingFFMpeg && !flagIsMadUsingFileReader )) {
00878 err = OMX_FreeBuffer(appPriv->audiodechandle, 0, inBufferAudioDec1);
00879 err = OMX_FreeBuffer(appPriv->audiodechandle, 0, inBufferAudioDec2);
00880 }
00881 DEBUG(DEB_LEV_PARAMS, "Free Audio dec output ports\n");
00882 if (!flagSetupTunnel) {
00883 err = OMX_FreeBuffer(appPriv->audiodechandle, 1, outBufferAudioDec1);
00884 err = OMX_FreeBuffer(appPriv->audiodechandle, 1, outBufferAudioDec2);
00885 }
00886
00887 if (!flagSetupTunnel && (flagUsingFFMpeg || flagIsMadUsingFileReader)) {
00888 err = OMX_FreeBuffer(appPriv->filereaderhandle, 0, outBufferFileRead1);
00889 err = OMX_FreeBuffer(appPriv->filereaderhandle, 0, outBufferFileRead2);
00890 }
00891
00892 if ((flagPlaybackOn) && (!flagSetupTunnel)) {
00893 err = OMX_FreeBuffer(appPriv->volumehandle, 0, inBufferVolume1);
00894 err = OMX_FreeBuffer(appPriv->volumehandle, 0, inBufferVolume2);
00895 err = OMX_FreeBuffer(appPriv->volumehandle, 1, outBufferVolume1);
00896 err = OMX_FreeBuffer(appPriv->volumehandle, 1, outBufferVolume2);
00897
00898 err = OMX_FreeBuffer(appPriv->audiosinkhandle, 0, inBufferSink1);
00899 err = OMX_FreeBuffer(appPriv->audiosinkhandle, 0, inBufferSink2);
00900 }
00901
00902 if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00903 tsem_down(appPriv->filereaderEventSem);
00904 DEBUG(DEFAULT_MESSAGES,"File reader loaded state \n");
00905 }
00906 tsem_down(appPriv->decoderEventSem);
00907 if (flagPlaybackOn) {
00908 tsem_down(appPriv->volumeEventSem);
00909 tsem_down(appPriv->sinkEventSem);
00910 }
00911
00912
00913 DEBUG(DEFAULT_MESSAGES, "All components released\n");
00914
00916 OMX_FreeHandle(appPriv->audiodechandle);
00917 DEBUG(DEB_LEV_SIMPLE_SEQ, "audiodec dec freed\n");
00918
00919 if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
00920 OMX_FreeHandle(appPriv->filereaderhandle);
00921 DEBUG(DEB_LEV_SIMPLE_SEQ, "filereader freed\n");
00922 }
00923
00924 if (flagPlaybackOn) {
00925 OMX_FreeHandle(appPriv->volumehandle);
00926 DEBUG(DEB_LEV_SIMPLE_SEQ, "volume component freed\n");
00927 OMX_FreeHandle(appPriv->audiosinkhandle);
00928 DEBUG(DEB_LEV_SIMPLE_SEQ, "audiosink freed\n");
00929 }
00930
00931 OMX_Deinit();
00932
00933 DEBUG(DEB_LEV_SIMPLE_SEQ, "All components freed. Closing...\n");
00934
00935 free(appPriv->filereaderEventSem);
00936 appPriv->filereaderEventSem = NULL;
00937
00938 free(appPriv->decoderEventSem);
00939 appPriv->decoderEventSem = NULL;
00940 if (flagPlaybackOn) {
00941 free(appPriv->volumeEventSem);
00942 appPriv->volumeEventSem = NULL;
00943
00944 free(appPriv->sinkEventSem);
00945 appPriv->sinkEventSem = NULL;
00946 }
00947
00948 free(appPriv->eofSem);
00949 appPriv->eofSem = NULL;
00950 free(appPriv);
00951 appPriv = NULL;
00952 if (flagOutputReceived) {
00953 fclose(outfile);
00954 }
00955
00956 if(!flagUsingFFMpeg && !flagIsMadUsingFileReader) {
00957 if(fclose(fd) != 0) {
00958 DEBUG(DEB_LEV_ERR,"Error in closing input file stream\n");
00959 exit(1);
00960 }
00961 else {
00962 DEBUG(DEB_LEV_SIMPLE_SEQ,"Succees in closing input file stream\n");
00963 }
00964 }
00965
00966 free(full_component_name);
00967 free(input_file);
00968 free(output_file);
00969 free(temp);
00970
00971 return 0;
00972 }
00973
00974
00975
00976 OMX_ERRORTYPE filereaderEventHandler(
00977 OMX_OUT OMX_HANDLETYPE hComponent,
00978 OMX_OUT OMX_PTR pAppData,
00979 OMX_OUT OMX_EVENTTYPE eEvent,
00980 OMX_OUT OMX_U32 Data1,
00981 OMX_OUT OMX_U32 Data2,
00982 OMX_OUT OMX_PTR pEventData)
00983 {
00984 OMX_PTR pExtraData;
00985 OMX_INDEXTYPE eIndexExtraData;
00986 OMX_ERRORTYPE err;
00987 DEBUG(DEB_LEV_SIMPLE_SEQ, "Hi there, I am in the %s callback\n", __func__);
00988
00989 if(eEvent == OMX_EventCmdComplete) {
00990 if (Data1 == OMX_CommandStateSet) {
00991 DEBUG(DEB_LEV_SIMPLE_SEQ, "File Reader State changed in ");
00992 switch ((int)Data2) {
00993 case OMX_StateInvalid:
00994 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
00995 break;
00996 case OMX_StateLoaded:
00997 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
00998 break;
00999 case OMX_StateIdle:
01000 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle\n");
01001 break;
01002 case OMX_StateExecuting:
01003 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
01004 break;
01005 case OMX_StatePause:
01006 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
01007 break;
01008 case OMX_StateWaitForResources:
01009 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
01010 break;
01011 }
01012 tsem_up(appPriv->filereaderEventSem);
01013 } else if (Data1 == OMX_CommandPortEnable){
01014 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable Event\n",__func__);
01015 tsem_up(appPriv->filereaderEventSem);
01016 } else if (Data1 == OMX_CommandPortDisable){
01017 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Disable Event\n",__func__);
01018 tsem_up(appPriv->filereaderEventSem);
01019 } else {
01020 DEBUG(DEB_LEV_SIMPLE_SEQ,"In %s Received Event Event=%d Data1=%d,Data2=%d\n",__func__,eEvent,(int)Data1,(int)Data2);
01021 }
01022 } else if(eEvent == OMX_EventPortSettingsChanged) {
01023 DEBUG(DEB_LEV_SIMPLE_SEQ,"File reader Port Setting Changed event\n");
01024 if(flagUsingFFMpeg) {
01025 err = OMX_GetExtensionIndex(appPriv->audiodechandle,"OMX.ST.index.config.audioextradata",&eIndexExtraData);
01026 if(err != OMX_ErrorNone) {
01027 DEBUG(DEB_LEV_ERR,"\n error in get extension index\n");
01028 exit(1);
01029 } else {
01030 pExtraData = malloc(extradata_size);
01031 err = OMX_GetConfig(appPriv->filereaderhandle, eIndexExtraData, pExtraData);
01032 if(err != OMX_ErrorNone) {
01033 DEBUG(DEB_LEV_ERR,"\n file reader Get Param Failed error =%08x index=%08x\n",err,eIndexExtraData);
01034 exit(1);
01035 }
01036 DEBUG(DEB_LEV_SIMPLE_SEQ,"Setting ExtraData\n");
01037 err = OMX_SetConfig(appPriv->audiodechandle, eIndexExtraData, pExtraData);
01038 if(err != OMX_ErrorNone) {
01039 DEBUG(DEB_LEV_ERR,"\n audio decoder Set Config Failed error=%08x\n",err);
01040 exit(1);
01041 }
01042 free(pExtraData);
01043 }
01044 }
01045
01046 tsem_up(appPriv->filereaderEventSem);
01047 } else if(eEvent == OMX_EventPortFormatDetected) {
01048 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Port Format Detected %x\n", __func__,(int)Data1);
01049 } else if(eEvent == OMX_EventBufferFlag) {
01050 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s OMX_BUFFERFLAG_EOS\n", __func__);
01051 if((int)Data2 == OMX_BUFFERFLAG_EOS) {
01052 tsem_up(appPriv->eofSem);
01053 }
01054 } else {
01055 DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
01056 DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
01057 }
01058 return OMX_ErrorNone;
01059 }
01060
01061 OMX_ERRORTYPE filereaderFillBufferDone(
01062 OMX_OUT OMX_HANDLETYPE hComponent,
01063 OMX_OUT OMX_PTR pAppData,
01064 OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
01065 {
01066 OMX_ERRORTYPE err;
01067
01068
01069 if(pBuffer != NULL){
01070 if(!bEOS) {
01071 if(inBufferAudioDec1->pBuffer == pBuffer->pBuffer) {
01072 inBufferAudioDec1->nFilledLen = pBuffer->nFilledLen;
01073 err = OMX_EmptyThisBuffer(appPriv->audiodechandle, inBufferAudioDec1);
01074 } else {
01075 inBufferAudioDec2->nFilledLen = pBuffer->nFilledLen;
01076 err = OMX_EmptyThisBuffer(appPriv->audiodechandle, inBufferAudioDec2);
01077 }
01078 if(err != OMX_ErrorNone) {
01079 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01080 }
01081 if(pBuffer->nFlags==OMX_BUFFERFLAG_EOS) {
01082 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Calling Empty This Buffer\n", __func__,(int)pBuffer->nFlags);
01083 bEOS=OMX_TRUE;
01084 }
01085 } else {
01086 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Dropping Empty This Buffer\n", __func__,(int)pBuffer->nFlags);
01087 }
01088 } else {
01089 DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
01090 }
01091 return OMX_ErrorNone;
01092 }
01093
01094 OMX_ERRORTYPE audiodecEventHandler(
01095 OMX_OUT OMX_HANDLETYPE hComponent,
01096 OMX_OUT OMX_PTR pAppData,
01097 OMX_OUT OMX_EVENTTYPE eEvent,
01098 OMX_OUT OMX_U32 Data1,
01099 OMX_OUT OMX_U32 Data2,
01100 OMX_OUT OMX_PTR pEventData)
01101 {
01102 OMX_ERRORTYPE err;
01103 OMX_PARAM_PORTDEFINITIONTYPE param;
01104 OMX_AUDIO_PARAM_PCMMODETYPE pcmParam;
01105
01106 DEBUG(DEB_LEV_SIMPLE_SEQ, "Hi there, I am in the %s callback\n", __func__);
01107 if(eEvent == OMX_EventCmdComplete) {
01108 if (Data1 == OMX_CommandStateSet) {
01109 DEBUG(DEB_LEV_SIMPLE_SEQ, "Audio Decoder State changed in ");
01110 switch ((int)Data2) {
01111 case OMX_StateInvalid:
01112 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
01113 break;
01114 case OMX_StateLoaded:
01115 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
01116 break;
01117 case OMX_StateIdle:
01118 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle\n");
01119 break;
01120 case OMX_StateExecuting:
01121 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
01122 break;
01123 case OMX_StatePause:
01124 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
01125 break;
01126 case OMX_StateWaitForResources:
01127 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
01128 break;
01129 }
01130 tsem_up(appPriv->decoderEventSem);
01131 } else if (Data1 == OMX_CommandPortEnable){
01132 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable Event\n",__func__);
01133 tsem_up(appPriv->decoderEventSem);
01134 } else if (Data1 == OMX_CommandPortDisable){
01135 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Disable Event\n",__func__);
01136 tsem_up(appPriv->decoderEventSem);
01137 }
01138 } else if(eEvent == OMX_EventPortSettingsChanged) {
01139 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Settings Changed Event\n", __func__);
01140 if (Data2 == 1) {
01141 param.nPortIndex = 1;
01142 setHeader(¶m, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
01143 err = OMX_GetParameter(appPriv->audiodechandle,OMX_IndexParamPortDefinition, ¶m);
01144
01145 pcmParam.nPortIndex=1;
01146 setHeader(&pcmParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
01147 err = OMX_GetParameter(appPriv->audiodechandle, OMX_IndexParamAudioPcm, &pcmParam);
01148
01149
01150 if ((flagPlaybackOn) && (!flagSetupTunnel)) {
01151
01152 err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandPortDisable, 0, NULL);
01153 if(err != OMX_ErrorNone) {
01154 DEBUG(DEB_LEV_ERR,"ALSA sink port disable failed\n");
01155 exit(1);
01156 }
01157
01158 err = OMX_FreeBuffer(appPriv->audiosinkhandle, 0, inBufferSink1);
01159 err = OMX_FreeBuffer(appPriv->audiosinkhandle, 0, inBufferSink2);
01160
01161
01162 tsem_down(appPriv->sinkEventSem);
01163
01164 pcmParam.nPortIndex=0;
01165 err = OMX_SetParameter(appPriv->audiosinkhandle, OMX_IndexParamAudioPcm, &pcmParam);
01166 if(err!=OMX_ErrorNone) {
01167 DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetParameter 0 \n",err);
01168 }
01169
01170 err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandPortEnable, 0, NULL);
01171 if(err != OMX_ErrorNone) {
01172 DEBUG(DEB_LEV_ERR,"ALSA sink port disable failed\n");
01173 exit(1);
01174 }
01175
01176 err = OMX_UseBuffer(appPriv->audiosinkhandle, &inBufferSink1, 0, NULL, buffer_out_size, outBufferVolume1->pBuffer);
01177 if(err != OMX_ErrorNone) {
01178 DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
01179 exit(1);
01180 }
01181 err = OMX_UseBuffer(appPriv->audiosinkhandle, &inBufferSink2, 0, NULL, buffer_out_size, outBufferVolume2->pBuffer);
01182 if(err != OMX_ErrorNone) {
01183 DEBUG(DEB_LEV_ERR, "Unable to use the allocated buffer\n");
01184 exit(1);
01185 }
01186
01187
01188 tsem_down(appPriv->sinkEventSem);
01189 DEBUG(DEB_LEV_SIMPLE_SEQ,"audio sink port enabled\n");
01190 } else if (flagPlaybackOn && flagSetupTunnel) {
01191
01192 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Volume Component Port Disabling\n", __func__);
01193
01194 err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandPortDisable, 1, NULL);
01195 if(err != OMX_ErrorNone) {
01196 DEBUG(DEB_LEV_ERR,"Volume Component port disable failed\n");
01197 exit(1);
01198 }
01199
01200 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Audio Sink Port Disabling\n", __func__);
01201 err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandPortDisable, 0, NULL);
01202 if(err != OMX_ErrorNone) {
01203 DEBUG(DEB_LEV_ERR,"alas sink port disable failed\n");
01204 exit(1);
01205 }
01206
01207
01208 tsem_down(appPriv->sinkEventSem);
01209 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Audio Sink Port Disabled\n", __func__);
01210 tsem_down(appPriv->volumeEventSem);
01211 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Volume Component Port Disabled\n", __func__);
01212
01213 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Audio Sink Setting Parameters\n", __func__);
01214
01215 pcmParam.nPortIndex=0;
01216 err = OMX_SetParameter(appPriv->audiosinkhandle, OMX_IndexParamAudioPcm, &pcmParam);
01217 if(err!=OMX_ErrorNone) {
01218 DEBUG(DEB_LEV_ERR,"Error %08x In OMX_SetParameter 0 \n",err);
01219 }
01220
01221 err = OMX_SendCommand(appPriv->volumehandle, OMX_CommandPortEnable, 1, NULL);
01222 err = OMX_SendCommand(appPriv->audiosinkhandle, OMX_CommandPortEnable, 0, NULL);
01223 if(err != OMX_ErrorNone) {
01224 DEBUG(DEB_LEV_ERR,"audio sink port enable failed\n");
01225 exit(1);
01226 }
01227
01228
01229 tsem_down(appPriv->volumeEventSem);
01230 tsem_down(appPriv->sinkEventSem);
01231 DEBUG(DEB_LEV_SIMPLE_SEQ,"audio sink port enabled\n");
01232 }
01233
01234 } else if (Data2 == 0) {
01235
01236 param.nPortIndex = 0;
01237 setHeader(¶m, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
01238 err = OMX_GetParameter(appPriv->audiodechandle,OMX_IndexParamPortDefinition, ¶m);
01239 }
01240 } else if(eEvent == OMX_EventBufferFlag) {
01241 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s OMX_BUFFERFLAG_EOS\n", __func__);
01242 if((int)Data2 == OMX_BUFFERFLAG_EOS) {
01243 tsem_up(appPriv->eofSem);
01244 }
01245 } else {
01246 DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
01247 DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
01248 }
01249
01250 return OMX_ErrorNone;
01251 }
01252
01253 OMX_ERRORTYPE audiodecEmptyBufferDone(
01254 OMX_OUT OMX_HANDLETYPE hComponent,
01255 OMX_OUT OMX_PTR pAppData,
01256 OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
01257 {
01258 OMX_ERRORTYPE err;
01259 int data_read;
01260 static int iBufferDropped=0;
01261 DEBUG(DEB_LEV_FULL_SEQ, "Hi there, I am in the %s callback.\n", __func__);
01262
01263 if(flagUsingFFMpeg || flagIsMadUsingFileReader) {
01264 if(pBuffer != NULL){
01265 if(!bEOS) {
01266 if(outBufferFileRead1->pBuffer == pBuffer->pBuffer) {
01267 outBufferFileRead1->nFilledLen=0;
01268 err = OMX_FillThisBuffer(appPriv->filereaderhandle, outBufferFileRead1);
01269 } else {
01270 outBufferFileRead2->nFilledLen=0;
01271 err = OMX_FillThisBuffer(appPriv->filereaderhandle, outBufferFileRead2);
01272 }
01273 if(err != OMX_ErrorNone) {
01274 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01275 }
01276 } else {
01277 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Dropping Fill This Buffer\n", __func__,(int)pBuffer->nFlags);
01278 iBufferDropped++;
01279 if(iBufferDropped==2) {
01280 tsem_up(appPriv->eofSem);
01281 }
01282 }
01283 } else {
01284 if(!bEOS) {
01285 DEBUG(DEB_LEV_SIMPLE_SEQ,"It is here EOS = %d\n",appPriv->eofSem->semval);
01286 tsem_up(appPriv->eofSem);
01287 }
01288 DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
01289 }
01290 } else {
01291
01292 data_read = fread(pBuffer->pBuffer, 1, buffer_in_size, fd);
01293 pBuffer->nFilledLen = data_read;
01294 pBuffer->nOffset = 0;
01295 if (data_read <= 0) {
01296 DEBUG(DEB_LEV_SIMPLE_SEQ, "In the %s no more input data available\n", __func__);
01297 iBufferDropped++;
01298 if(iBufferDropped>=2) {
01299 tsem_up(appPriv->eofSem);
01300 return OMX_ErrorNone;
01301 }
01302 pBuffer->nFilledLen=0;
01303 pBuffer->nFlags = OMX_BUFFERFLAG_EOS;
01304 bEOS=OMX_TRUE;
01305 err = OMX_EmptyThisBuffer(hComponent, pBuffer);
01306 return OMX_ErrorNone;
01307 }
01308 pBuffer->nFilledLen = data_read;
01309 if(!bEOS) {
01310 DEBUG(DEB_LEV_FULL_SEQ, "Empty buffer %x\n", (int)pBuffer);
01311 err = OMX_EmptyThisBuffer(hComponent, pBuffer);
01312 } else {
01313 DEBUG(DEB_LEV_FULL_SEQ, "In %s Dropping Empty This buffer to Audio Dec\n", __func__);
01314 }
01315 }
01316
01317 return OMX_ErrorNone;
01318 }
01319
01320 OMX_ERRORTYPE audiodecFillBufferDone(
01321 OMX_OUT OMX_HANDLETYPE hComponent,
01322 OMX_OUT OMX_PTR pAppData,
01323 OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
01324 {
01325 OMX_ERRORTYPE err;
01326 int i;
01327 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s \n",__func__);
01328
01329 if(pBuffer != NULL){
01330 if (pBuffer->nFilledLen == 0) {
01331 DEBUG(DEB_LEV_ERR, "Ouch! In %s: had 0 data size in output buffer...\n", __func__);
01332 return OMX_ErrorNone;
01333 }
01334 if ((!flagOutputReceived) && (!flagPlaybackOn) && (flagDirect)) {
01335 for(i = 0; i<pBuffer->nFilledLen; i++){
01336 putchar(*(char*)(pBuffer->pBuffer + i));
01337 }
01338 pBuffer->nFilledLen = 0;
01339 err = OMX_FillThisBuffer(hComponent, pBuffer);
01340 if(err != OMX_ErrorNone) {
01341 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01342 }
01343 } else if ((flagOutputReceived) && (!flagPlaybackOn)) {
01344 if(pBuffer->nFilledLen > 0) {
01345 fwrite(pBuffer->pBuffer, 1, pBuffer->nFilledLen, outfile);
01346 }
01347 pBuffer->nFilledLen = 0;
01348 err = OMX_FillThisBuffer(hComponent, pBuffer);
01349 if(err != OMX_ErrorNone) {
01350 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01351 }
01352 } else if ((!flagSetupTunnel) && (flagPlaybackOn)) {
01353 if(inBufferVolume1->pBuffer == pBuffer->pBuffer) {
01354 inBufferVolume1->nFilledLen = pBuffer->nFilledLen;
01355 err = OMX_EmptyThisBuffer(appPriv->volumehandle, inBufferVolume1);
01356 } else {
01357 inBufferVolume2->nFilledLen = pBuffer->nFilledLen;
01358 err = OMX_EmptyThisBuffer(appPriv->volumehandle, inBufferVolume2);
01359 }
01360 if(err != OMX_ErrorNone) {
01361 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling EmptyThisBuffer\n", __func__,err);
01362 }
01363 }
01364 } else {
01365 DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
01366 }
01367 return OMX_ErrorNone;
01368 }
01369
01370 OMX_ERRORTYPE volumeEventHandler(
01371 OMX_OUT OMX_HANDLETYPE hComponent,
01372 OMX_OUT OMX_PTR pAppData,
01373 OMX_OUT OMX_EVENTTYPE eEvent,
01374 OMX_OUT OMX_U32 Data1,
01375 OMX_OUT OMX_U32 Data2,
01376 OMX_OUT OMX_PTR pEventData)
01377 {
01378
01379 DEBUG(DEB_LEV_SIMPLE_SEQ, "Hi there, I am in the %s callback\n", __func__);
01380 if(eEvent == OMX_EventCmdComplete) {
01381 if (Data1 == OMX_CommandStateSet) {
01382 DEBUG(DEB_LEV_SIMPLE_SEQ, "Audio Decoder State changed in ");
01383 switch ((int)Data2) {
01384 case OMX_StateInvalid:
01385 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
01386 break;
01387 case OMX_StateLoaded:
01388 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
01389 break;
01390 case OMX_StateIdle:
01391 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle\n");
01392 break;
01393 case OMX_StateExecuting:
01394 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
01395 break;
01396 case OMX_StatePause:
01397 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
01398 break;
01399 case OMX_StateWaitForResources:
01400 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
01401 break;
01402 }
01403 tsem_up(appPriv->volumeEventSem);
01404 } else if (Data1 == OMX_CommandPortEnable){
01405 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable Event\n",__func__);
01406 tsem_up(appPriv->volumeEventSem);
01407 } else if (Data1 == OMX_CommandPortDisable){
01408 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Disable Event\n",__func__);
01409 tsem_up(appPriv->volumeEventSem);
01410 }
01411 } else if(eEvent == OMX_EventBufferFlag) {
01412 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s OMX_BUFFERFLAG_EOS\n", __func__);
01413 if((int)Data2 == OMX_BUFFERFLAG_EOS) {
01414 tsem_up(appPriv->eofSem);
01415 }
01416 } else {
01417 DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
01418 DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
01419 }
01420
01421 return OMX_ErrorNone;
01422 }
01423
01424 OMX_ERRORTYPE volumeEmptyBufferDone(
01425 OMX_OUT OMX_HANDLETYPE hComponent,
01426 OMX_OUT OMX_PTR pAppData,
01427 OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
01428 {
01429 OMX_ERRORTYPE err;
01430 static int iBufferDropped=0;
01431 DEBUG(DEB_LEV_FULL_SEQ, "Hi there, I am in the %s callback.\n", __func__);
01432
01433 if(pBuffer != NULL){
01434 if(!bEOS) {
01435 if(outBufferAudioDec1->pBuffer == pBuffer->pBuffer) {
01436 outBufferAudioDec1->nFilledLen=0;
01437 err = OMX_FillThisBuffer(appPriv->audiodechandle, outBufferAudioDec1);
01438 } else {
01439 outBufferAudioDec2->nFilledLen=0;
01440 err = OMX_FillThisBuffer(appPriv->audiodechandle, outBufferAudioDec2);
01441 }
01442 if(err != OMX_ErrorNone) {
01443 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01444 }
01445 } else {
01446 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s: eos=%x Dropping Fill This Buffer\n", __func__,(int)pBuffer->nFlags);
01447 iBufferDropped++;
01448 if(iBufferDropped==2) {
01449 tsem_up(appPriv->eofSem);
01450 }
01451 }
01452 } else {
01453 if(!bEOS) {
01454 DEBUG(DEFAULT_MESSAGES,"It is here EOS = %d\n",appPriv->eofSem->semval);
01455 tsem_up(appPriv->eofSem);
01456 }
01457 DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
01458 }
01459 return OMX_ErrorNone;
01460 }
01461
01462 OMX_ERRORTYPE volumeFillBufferDone(
01463 OMX_OUT OMX_HANDLETYPE hComponent,
01464 OMX_OUT OMX_PTR pAppData,
01465 OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
01466 {
01467 OMX_ERRORTYPE err;
01468 int i;
01469 static int volCompBufferDropped=0;
01470 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s \n",__func__);
01471
01472 if(pBuffer != NULL){
01473 if (pBuffer->nFilledLen == 0) {
01474 DEBUG(DEB_LEV_ERR, "Ouch! In %s: had 0 data size in output buffer...\n", __func__);
01475 return OMX_ErrorNone;
01476 }
01477 if ((!flagOutputReceived) && (!flagPlaybackOn) && (flagDirect)) {
01478 for(i = 0; i<pBuffer->nFilledLen; i++){
01479 putchar(*(char*)(pBuffer->pBuffer + i));
01480 }
01481 pBuffer->nFilledLen = 0;
01482 err = OMX_FillThisBuffer(hComponent, pBuffer);
01483 if(err != OMX_ErrorNone) {
01484 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01485 }
01486 } else if ((flagOutputReceived) && (!flagPlaybackOn)) {
01487 if(pBuffer->nFilledLen > 0) {
01488 fwrite(pBuffer->pBuffer, 1, pBuffer->nFilledLen, outfile);
01489 }
01490 pBuffer->nFilledLen = 0;
01491 err = OMX_FillThisBuffer(hComponent, pBuffer);
01492 if(err != OMX_ErrorNone) {
01493 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01494 }
01495 } else if ((!flagSetupTunnel) && (flagPlaybackOn)) {
01496 if(!bEOS) {
01497 if(inBufferSink1->pBuffer == pBuffer->pBuffer) {
01498 inBufferSink1->nFilledLen = pBuffer->nFilledLen;
01499 err = OMX_EmptyThisBuffer(appPriv->audiosinkhandle, inBufferSink1);
01500 } else {
01501 inBufferSink2->nFilledLen = pBuffer->nFilledLen;
01502 err = OMX_EmptyThisBuffer(appPriv->audiosinkhandle, inBufferSink2);
01503 }
01504 if(err != OMX_ErrorNone) {
01505 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling EmptyThisBuffer\n", __func__,err);
01506 }
01507 } else {
01508 DEBUG(DEFAULT_MESSAGES,"In %s EOS reached\n",__func__);
01509 volCompBufferDropped++;
01510 if(volCompBufferDropped==2) {
01511 tsem_up(appPriv->eofSem);
01512 }
01513 }
01514
01515 }
01516 } else {
01517 DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
01518 }
01519 return OMX_ErrorNone;
01520 }
01521
01522
01523 OMX_ERRORTYPE audiosinkEventHandler(
01524 OMX_OUT OMX_HANDLETYPE hComponent,
01525 OMX_OUT OMX_PTR pAppData,
01526 OMX_OUT OMX_EVENTTYPE eEvent,
01527 OMX_OUT OMX_U32 Data1,
01528 OMX_OUT OMX_U32 Data2,
01529 OMX_OUT OMX_PTR pEventData) {
01530 DEBUG(DEB_LEV_SIMPLE_SEQ, "Hi there, I am in the %s callback\n", __func__);
01531 if (Data1 == OMX_CommandStateSet) {
01532 DEBUG(DEB_LEV_SIMPLE_SEQ, "Audio Sink State changed in ");
01533 switch ((int)Data2) {
01534 case OMX_StateInvalid:
01535 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateInvalid\n");
01536 break;
01537 case OMX_StateLoaded:
01538 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateLoaded\n");
01539 break;
01540 case OMX_StateIdle:
01541 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateIdle\n");
01542 break;
01543 case OMX_StateExecuting:
01544 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateExecuting\n");
01545 break;
01546 case OMX_StatePause:
01547 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StatePause\n");
01548 break;
01549 case OMX_StateWaitForResources:
01550 DEBUG(DEB_LEV_SIMPLE_SEQ, "OMX_StateWaitForResources\n");
01551 break;
01552 }
01553 tsem_up(appPriv->sinkEventSem);
01554 } else if (Data1 == OMX_CommandPortEnable){
01555 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Enable Event\n",__func__);
01556 tsem_up(appPriv->sinkEventSem);
01557 } else if (Data1 == OMX_CommandPortDisable){
01558 DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Received Port Disable Event\n",__func__);
01559 tsem_up(appPriv->sinkEventSem);
01560 } else {
01561 DEBUG(DEB_LEV_SIMPLE_SEQ, "Param1 is %i\n", (int)Data1);
01562 DEBUG(DEB_LEV_SIMPLE_SEQ, "Param2 is %i\n", (int)Data2);
01563 }
01564
01565 return OMX_ErrorNone;
01566 }
01567
01568 OMX_ERRORTYPE audiosinkEmptyBufferDone(
01569 OMX_OUT OMX_HANDLETYPE hComponent,
01570 OMX_OUT OMX_PTR pAppData,
01571 OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer)
01572 {
01573 OMX_ERRORTYPE err;
01574 static int alsaSinkBufferDropped=0;
01575 DEBUG(DEB_LEV_FULL_SEQ, "Hi there, I am in the %s callback.\n", __func__);
01576
01577 DEBUG(DEB_LEV_PARAMS, "Empty buffer %x\n", (int)pBuffer);
01578 if(!bEOS) {
01579 if(outBufferVolume1->pBuffer == pBuffer->pBuffer) {
01580 outBufferVolume1->nFilledLen=0;
01581 err = OMX_FillThisBuffer(appPriv->volumehandle, outBufferVolume1);
01582 } else {
01583 outBufferVolume2->nFilledLen=0;
01584 err = OMX_FillThisBuffer(appPriv->volumehandle, outBufferVolume2);
01585 }
01586 if(err != OMX_ErrorNone) {
01587 DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
01588 }
01589 } else {
01590 DEBUG(DEFAULT_MESSAGES,"In %s EOS reached\n",__func__);
01591 alsaSinkBufferDropped++;
01592 if(alsaSinkBufferDropped==2) {
01593 tsem_up(appPriv->eofSem);
01594 }
01595 }
01596
01597 return OMX_ErrorNone;
01598 }
01599