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