/*----------------------------------------------------------------------------*/ /* Includes */ /*----------------------------------------------------------------------------*/ #define _DATASTRUCT_C_ #include /*----------------------------------------------------------------------------*/ /* */ /*----------------------------------------------------------------------------*/ NDT_Status DR_Layer_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list *Args_Ptr) { NDT_Command_Name Command_Name; switch( Command) { case NDD_CMD_MANAGER_VERSION: { ND_VA_ARG_GET( Version_Name_Ptr, *Args_Ptr, NDT_Version_Name *); Command_Name = "NDD_CMD_MANAGER_VERSION"; *Version_Name_Ptr = "$Revision: 1.0 $ $Name: Layer_Manager $ $Date: 2021/12/12 21:27:12 $ $Author: agibert $"; return( NDS_OK); } case NDD_CMD_INDEX_GET: { ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *); ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *); ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command); ND_VA_ARG_GET( Layer_Ptr, *Args_Ptr, DRT_Layer *); Command_Name = "NDD_CMD_INDEX_GET"; switch(Cmd) { case NDD_CMD_INDEX0_PRINT: { *Reply_Index_Id_Ptr = 0; *Reply_Command_Ptr = Cmd; break; } case NDD_CMD_INDEX1_PRINT: { *Reply_Index_Id_Ptr = 1; *Reply_Command_Ptr = Cmd; break; } default: { *Reply_Index_Id_Ptr = Index_Id; *Reply_Command_Ptr = Cmd; break; } } return( NDS_OK); } case NDD_CMD_VALUE_ALLOC: { ND_VA_ARG_GET( Layer_Ptr_Ptr, *Args_Ptr, DRT_Layer **); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( Layer_Template_Ptr, user_args, DRT_Layer *); ND_VA_LIST_CLOSE( user_args); Command_Name = "NDD_CMD_VALUE_ALLOC"; if( ( *Layer_Ptr_Ptr = (DRT_Layer *)malloc( sizeof( DRT_Layer))) != NULL) { ( *Layer_Ptr_Ptr)->Id = Root_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number; strncpy( ( *Layer_Ptr_Ptr)->FileName, Layer_Template_Ptr->FileName, DRD_FILENAME_SIZE); ( *Layer_Ptr_Ptr)->Sample_Ptr = Layer_Template_Ptr->Sample_Ptr; ( *Layer_Ptr_Ptr)->Sample_Size = Layer_Template_Ptr->Sample_Size; ( *Layer_Ptr_Ptr)->SF_Info_Ptr = Layer_Template_Ptr->SF_Info_Ptr; ( *Layer_Ptr_Ptr)->Min = Layer_Template_Ptr->Min; ( *Layer_Ptr_Ptr)->Max = Layer_Template_Ptr->Max; ( *Layer_Ptr_Ptr)->Gain = Layer_Template_Ptr->Gain; ( *Layer_Ptr_Ptr)->Pitch = Layer_Template_Ptr->Pitch; return( NDS_OK); } else { return( NDS_KO); } } case NDD_CMD_VALUE_FREE: { ND_VA_ARG_GET( Layer_Ptr, *Args_Ptr, DRT_Layer *); Command_Name = "NDD_CMD_VALUE_FREE"; DR_Layer_Sample_UnLoad( Layer_Ptr); free( Layer_Ptr); return( NDS_OK); } case NDD_CMD_VALUE_COMP: { ND_VA_ARG_GET( Layer1_Ptr, *Args_Ptr, DRT_Layer *); ND_VA_ARG_GET( Layer2_Ptr, *Args_Ptr, DRT_Layer *); long rc; Command_Name = "NDD_CMD_VALUE_COMP"; switch( Index_Id) { case 0: { rc = Layer1_Ptr->Id - Layer2_Ptr->Id; break; } case 1: { rc = strcmp( Layer1_Ptr->FileName, Layer2_Ptr->FileName); break; } default: { printf( "Unknown COMP idx (%d)!\n", Index_Id); return( NDS_KO); } } if( rc < 0) { return( NDS_LOWER); } else { if( rc > 0) { return( NDS_GREATER); } else { return( NDS_EQUAL); } } } case NDD_CMD_VALUE_ADD: { /* ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( user_data, user_args, user_type); ND_VA_ARG_GET( ..., user_args, ...); ND_VA_LIST_CLOSE( user_args); */ Command_Name = "NDD_CMD_VALUE_ADD"; return( NDS_OK); } case NDD_CMD_VALUE_REMOVE: { /* ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( user_data, user_args, user_type); ND_VA_ARG_GET( ..., user_args, ...); ND_VA_LIST_CLOSE( user_args); */ Command_Name = "NDD_CMD_VALUE_REMOVE"; return( NDS_OK); } case NDD_CMD_VALUE_PRINT: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( lib_args, *Args_Ptr); ND_VA_ARG_GET( Out, lib_args, FILE *); ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); ND_VA_LIST_OPEN( user_args, lib_args); ND_VA_ARG_GET( Count_Ptr, user_args, long *); ND_VA_LIST_CLOSE( user_args); ND_VA_LIST_CLOSE( lib_args); DRT_Layer *Layer_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_VALUE_PRINT"; if( DR_Layer_Dump( Layer_Ptr, ++(*Count_Ptr)) != DRS_OK) { return( NDS_KO); } else { return( NDS_OK); } } case NDD_CMD_INFO_PRINT: { Command_Name = "NDD_CMD_INFO_PRINT"; return( NDS_OK); } case NDD_CMD_INDEX0_PRINT: case NDD_CMD_INDEX1_PRINT: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( Out, user_args, FILE *); ND_VA_ARG_GET( Count_Ptr, user_args, long *); ND_VA_LIST_CLOSE( user_args); DRT_Layer *Layer_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_INDEX_PRINT"; if( DR_Layer_Dump( Layer_Ptr, ++(*Count_Ptr)) != DRS_OK) { return( NDS_KO); } else { return( NDS_OK); } } case NDD_CMD_STATS_GET: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( Layer_Count_Ptr, user_args, long *); ND_VA_ARG_GET( Sample_Count_Ptr, user_args, long *); ND_VA_LIST_CLOSE( user_args); DRT_Layer *Layer_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_STATS_GET"; (*Layer_Count_Ptr)++; if( Layer_Ptr->Sample_Ptr != NULL) { (*Sample_Count_Ptr)++; } return( NDS_OK); } case NDD_CMD_SAMPLE_LOAD: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( Kit_Ptr, user_args, DRT_Kit *); ND_VA_ARG_GET( SampleRate, user_args, DRT_SampleRate); ND_VA_LIST_CLOSE( user_args); DRT_Layer *Layer_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_SAMPLE_LOAD"; if( DR_Layer_Sample_Load( Layer_Ptr, Kit_Ptr, SampleRate) != DRS_OK) { return( NDS_OK); // Continue even if sample loading fail... } else { return( NDS_OK); } } case NDD_CMD_SAMPLE_UNLOAD: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( Kit_Ptr, user_args, DRT_Kit *); ND_VA_LIST_CLOSE( user_args); DRT_Layer *Layer_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_SAMPLE_UNLOAD"; if( DR_Layer_Sample_UnLoad( Layer_Ptr) != DRS_OK) { return( NDS_OK); // Continue even if sample unloading fail... } else { return( NDS_OK); } } default: { printf( "Layer_Manager() called with an undefined command %d\n", Command); return( NDS_ERRAPI); } } printf( "Layer_Manager() called with command %d (%s)\n", Command, Command_Name); return( NDS_OK); } /*----------------------------------------------------------------------------*/ /* */ /*----------------------------------------------------------------------------*/ NDT_Status DR_Instrument_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list *Args_Ptr) { NDT_Command_Name Command_Name; switch( Command) { case NDD_CMD_MANAGER_VERSION: { ND_VA_ARG_GET( Version_Name_Ptr, *Args_Ptr, NDT_Version_Name *); Command_Name = "NDD_CMD_MANAGER_VERSION"; *Version_Name_Ptr = "$Revision: 1.0 $ $Name: Instrument_Manager $ $Date: 2021/12/12 21:27:12 $ $Author: agibert $"; return( NDS_OK); } case NDD_CMD_INDEX_GET: { ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *); ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *); ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command); ND_VA_ARG_GET( Instrument_Ptr, *Args_Ptr, DRT_Instrument *); Command_Name = "NDD_CMD_INDEX_GET"; switch(Cmd) { case NDD_CMD_INDEX0_PRINT: { *Reply_Index_Id_Ptr = 0; *Reply_Command_Ptr = Cmd; break; } case NDD_CMD_INDEX1_PRINT: { *Reply_Index_Id_Ptr = 1; *Reply_Command_Ptr = Cmd; break; } default: { *Reply_Index_Id_Ptr = Index_Id; *Reply_Command_Ptr = Cmd; break; } } return( NDS_OK); } case NDD_CMD_VALUE_ALLOC: { ND_VA_ARG_GET( Instrument_Ptr_Ptr, *Args_Ptr, DRT_Instrument **); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( Instrument_Template_Ptr, user_args, DRT_Instrument *); ND_VA_LIST_CLOSE( user_args); NDT_Status nd_status; Command_Name = "NDD_CMD_VALUE_ALLOC"; if( ( *Instrument_Ptr_Ptr = (DRT_Instrument *)malloc( sizeof( DRT_Instrument))) != NULL) { ( *Instrument_Ptr_Ptr)->Id = Root_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number; strncpy( ( *Instrument_Ptr_Ptr)->Name, Instrument_Template_Ptr->Name, DRD_NAME_SIZE); ( *Instrument_Ptr_Ptr)->Gain = Instrument_Template_Ptr->Gain; ( *Instrument_Ptr_Ptr)->Pan_Left = Instrument_Template_Ptr->Pan_Left; ( *Instrument_Ptr_Ptr)->Pan_Right = Instrument_Template_Ptr->Pan_Right; if( ( nd_status = ND_DataStruct_Open( &((*Instrument_Ptr_Ptr)->Layer_DS_Ptr), DRD_LAYER_DS_INDEX_NB, DRG_Layer_DS_Index_Tab_Initial, "Layer_Manager", DR_Layer_Manager, NULL, NULL, NULL, NULL, NDD_TRUE, NULL)) != NDS_OK) { printf( "DR_Instrument_Manager: ND_DataStruct_Open() failed (%d)!\n", nd_status); return( NDS_KO); } else { return( NDS_OK); } } else { return( NDS_KO); } } case NDD_CMD_VALUE_FREE: { ND_VA_ARG_GET( Instrument_Ptr, *Args_Ptr, DRT_Instrument *); NDT_Status nd_status; Command_Name = "NDD_CMD_VALUE_FREE"; if( ( nd_status = ND_DataStruct_Close( Instrument_Ptr->Layer_DS_Ptr)) != NDS_OK) { printf( "DR_Instrument_Manager: Can't close Kit_DS (%d)!\n", nd_status); return( DRS_KO); } free( Instrument_Ptr); return( NDS_OK); } case NDD_CMD_VALUE_COMP: { ND_VA_ARG_GET( Instrument1_Ptr, *Args_Ptr, DRT_Instrument *); ND_VA_ARG_GET( Instrument2_Ptr, *Args_Ptr, DRT_Instrument *); long rc; Command_Name = "NDD_CMD_VALUE_COMP"; switch( Index_Id) { case 0: { rc = Instrument1_Ptr->Id - Instrument2_Ptr->Id; break; } case 1: { rc = strcmp( Instrument1_Ptr->Name, Instrument2_Ptr->Name); break; } default: { printf( "Unknown COMP idx (%d)!\n", Index_Id); return( NDS_KO); } } if( rc < 0) { return( NDS_LOWER); } else { if( rc > 0) { return( NDS_GREATER); } else { return( NDS_EQUAL); } } } case NDD_CMD_VALUE_ADD: { /* ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( user_data, user_args, user_type); ND_VA_ARG_GET( ..., user_args, ...); ND_VA_LIST_CLOSE( user_args); */ Command_Name = "NDD_CMD_VALUE_ADD"; return( NDS_OK); } case NDD_CMD_VALUE_REMOVE: { /* ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( user_data, user_args, user_type); ND_VA_ARG_GET( ..., user_args, ...); ND_VA_LIST_CLOSE( user_args); */ Command_Name = "NDD_CMD_VALUE_REMOVE"; return( NDS_OK); } case NDD_CMD_VALUE_PRINT: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( lib_args, *Args_Ptr); ND_VA_ARG_GET( Out, lib_args, FILE *); ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); ND_VA_LIST_OPEN( user_args, lib_args); ND_VA_ARG_GET( Count_Ptr, user_args, long *); ND_VA_LIST_CLOSE( user_args); ND_VA_LIST_CLOSE( lib_args); DRT_Instrument *Instrument_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_VALUE_PRINT"; if( DR_Instrument_Dump( Instrument_Ptr, ++(*Count_Ptr)) != DRS_OK) { return( NDS_KO); } else { return( NDS_OK); } } case NDD_CMD_INFO_PRINT: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( lib_args, *Args_Ptr); ND_VA_ARG_GET( Out, lib_args, FILE *); ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); ND_VA_LIST_CLOSE( lib_args); NDT_Status nd_status; DRT_Instrument *Instrument_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_INFO_PRINT"; if( ( nd_status = ND_DataStruct_Info_Print( Out, Instrument_Ptr->Layer_DS_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0)) != NDS_OK) { printf( "DR_Instrument_Manager: ND_DataStruct_Info_Print() failed (%d)!\n", nd_status); return( DRS_KO); } return( NDS_OK); } case NDD_CMD_INDEX0_PRINT: case NDD_CMD_INDEX1_PRINT: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( Out, user_args, FILE *); ND_VA_ARG_GET( Count_Ptr, user_args, long *); ND_VA_LIST_CLOSE( user_args); DRT_Instrument *Instrument_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_INDEX_PRINT"; if( DR_Instrument_Dump( Instrument_Ptr, ++(*Count_Ptr)) != DRS_OK) { return( NDS_KO); } else { return( NDS_OK); } } case NDD_CMD_STATS_GET: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( Instrument_Count_Ptr, user_args, long *); ND_VA_ARG_GET( Layer_Count_Ptr, user_args, long *); ND_VA_ARG_GET( Sample_Count_Ptr, user_args, long *); ND_VA_LIST_CLOSE( user_args); DRT_Instrument *Instrument_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_STATS_GET"; (*Instrument_Count_Ptr)++; // (*Layers_Count_Ptr) += Instrument_Ptr->Layer_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number; // return( NDS_OK); return( ND_DataStruct_Traverse( Instrument_Ptr->Layer_DS_Ptr, NDD_CMD_STATS_GET, Layer_Count_Ptr, Sample_Count_Ptr)); } case NDD_CMD_SAMPLE_LOAD: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( Kit_Ptr, user_args, DRT_Kit *); ND_VA_ARG_GET( SampleRate, user_args, DRT_SampleRate); ND_VA_LIST_CLOSE( user_args); DRT_Instrument *Instrument_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_SAMPLE_LOAD"; return( ND_DataStruct_Traverse( Instrument_Ptr->Layer_DS_Ptr, NDD_CMD_SAMPLE_LOAD, Kit_Ptr, SampleRate)); } case NDD_CMD_SAMPLE_UNLOAD: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( Kit_Ptr, user_args, DRT_Kit *); ND_VA_LIST_CLOSE( user_args); DRT_Instrument *Instrument_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_SAMPLE_UNLOAD"; return( ND_DataStruct_Traverse( Instrument_Ptr->Layer_DS_Ptr, NDD_CMD_SAMPLE_UNLOAD, Kit_Ptr)); } default: { printf( "Instrument_Manager() called with an undefined command %d\n", Command); return( NDS_ERRAPI); } } printf( "Instrument_Manager() called with command %d (%s)\n", Command, Command_Name); return( NDS_OK); } /*----------------------------------------------------------------------------*/ /* */ /*----------------------------------------------------------------------------*/ NDT_Status DR_Kit_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list *Args_Ptr) { NDT_Command_Name Command_Name; switch( Command) { case NDD_CMD_MANAGER_VERSION: { ND_VA_ARG_GET( Version_Name_Ptr, *Args_Ptr, NDT_Version_Name *); Command_Name = "NDD_CMD_MANAGER_VERSION"; *Version_Name_Ptr = "$Revision: 1.0 $ $Name: Kit_Manager $ $Date: 2021/12/12 21:27:12 $ $Author: agibert $"; return( NDS_OK); } case NDD_CMD_INDEX_GET: { ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *); ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *); ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command); ND_VA_ARG_GET( Kit_Ptr, *Args_Ptr, DRT_Kit *); Command_Name = "NDD_CMD_INDEX_GET"; switch(Cmd) { /* case NDT_CMD_SOME_USER_CMD: { *Reply_Index_Id_Ptr = 0; *Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD; break; } ... */ case NDD_CMD_VALUE_FIND: { if( Kit_Ptr->Name[0] == 0) { *Reply_Index_Id_Ptr = 0; } else { *Reply_Index_Id_Ptr = 1; } *Reply_Command_Ptr = Cmd; break; } case NDD_CMD_INDEX0_PRINT: { *Reply_Index_Id_Ptr = 0; *Reply_Command_Ptr = Cmd; break; } case NDD_CMD_VALUE_PRINT: case NDD_CMD_INDEX1_PRINT: { *Reply_Index_Id_Ptr = 1; *Reply_Command_Ptr = Cmd; break; } default: { *Reply_Index_Id_Ptr = Index_Id; *Reply_Command_Ptr = Cmd; break; } } return( NDS_OK); } case NDD_CMD_VALUE_ALLOC: { ND_VA_ARG_GET( Kit_Ptr_Ptr, *Args_Ptr, DRT_Kit **); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( Kit_Template_Ptr, user_args, DRT_Kit *); ND_VA_LIST_CLOSE( user_args); NDT_Status nd_status; Command_Name = "NDD_CMD_VALUE_ALLOC"; if( ( *Kit_Ptr_Ptr = (DRT_Kit *)malloc( sizeof( DRT_Kit))) != NULL) { ( *Kit_Ptr_Ptr)->Id = Root_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number; ( *Kit_Ptr_Ptr)->Status = Kit_Template_Ptr->Status; strncpy( ( *Kit_Ptr_Ptr)->Name, Kit_Template_Ptr->Name, DRD_NAME_SIZE); strncpy( ( *Kit_Ptr_Ptr)->Desc, Kit_Template_Ptr->Desc, DRD_DESC_SIZE); strncpy( ( *Kit_Ptr_Ptr)->DirName, Kit_Template_Ptr->DirName, DRD_DIRNAME_SIZE); if( ( nd_status = ND_DataStruct_Open( &((*Kit_Ptr_Ptr)->Instrument_DS_Ptr), DRD_INSTRUMENT_DS_INDEX_NB, DRG_Instrument_DS_Index_Tab_Initial, "Instrument_Manager", DR_Instrument_Manager, NULL, NULL, NULL, NULL, NDD_TRUE, NULL)) != NDS_OK) { printf( "DR_Kit_Manager: ND_DataStruct_Open() failed (%d)!\n", nd_status); return( NDS_KO); } return( NDS_OK); } else { return( NDS_KO); } } case NDD_CMD_VALUE_FREE: { ND_VA_ARG_GET( Kit_Ptr, *Args_Ptr, DRT_Kit *); NDT_Status nd_status; Command_Name = "NDD_CMD_VALUE_FREE"; if( ( nd_status = ND_DataStruct_Close( Kit_Ptr->Instrument_DS_Ptr)) != NDS_OK) { printf( "DR_Kit_Manager: Can't close Kit_DS (%d)!\n", nd_status); return( DRS_KO); } free( Kit_Ptr); return( NDS_OK); } case NDD_CMD_VALUE_COMP: { ND_VA_ARG_GET( Kit1_Ptr, *Args_Ptr, DRT_Kit *); ND_VA_ARG_GET( Kit2_Ptr, *Args_Ptr, DRT_Kit *); long rc; Command_Name = "NDD_CMD_VALUE_COMP"; switch( Index_Id) { case 0: { rc = Kit1_Ptr->Id - Kit2_Ptr->Id; break; } case 1: { rc = strcmp( Kit1_Ptr->Name, Kit2_Ptr->Name); break; } default: { printf( "Unknown COMP idx (%d)!\n", Index_Id); return( NDS_KO); } } if( rc < 0) { return( NDS_LOWER); } else { if( rc > 0) { return( NDS_GREATER); } else { return( NDS_EQUAL); } } } case NDD_CMD_VALUE_ADD: { /* ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( user_data, user_args, user_type); ND_VA_ARG_GET( ..., user_args, ...); ND_VA_LIST_CLOSE( user_args); */ Command_Name = "NDD_CMD_VALUE_ADD"; return( NDS_OK); } case NDD_CMD_VALUE_REMOVE: { /* ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( user_data, user_args, user_type); ND_VA_ARG_GET( ..., user_args, ...); ND_VA_LIST_CLOSE( user_args); */ Command_Name = "NDD_CMD_VALUE_REMOVE"; return( NDS_OK); } case NDD_CMD_VALUE_PRINT: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( lib_args, *Args_Ptr); ND_VA_ARG_GET( Out, lib_args, FILE *); ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); ND_VA_LIST_OPEN( user_args, lib_args); ND_VA_ARG_GET( Count_Ptr, user_args, long *); ND_VA_LIST_CLOSE( user_args); ND_VA_LIST_CLOSE( lib_args); DRT_Kit *Kit_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_VALUE_PRINT"; if( DR_Kit_Dump( Kit_Ptr, ++(*Count_Ptr)) != DRS_OK) { return( NDS_KO); } else { return( NDS_OK); } } case NDD_CMD_INFO_PRINT: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( lib_args, *Args_Ptr); ND_VA_ARG_GET( Out, lib_args, FILE *); ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode); ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth); ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset); ND_VA_LIST_CLOSE( lib_args); NDT_Status nd_status; DRT_Kit *Kit_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_INFO_PRINT"; if( ( nd_status = ND_DataStruct_Info_Print( Out, Kit_Ptr->Instrument_DS_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0)) != NDS_OK) { printf( "DR_Kit_Manager: ND_DataStruct_Info_Print() failed (%d)!\n", nd_status); return( DRS_KO); } return( NDS_OK); } case NDD_CMD_INDEX0_PRINT: case NDD_CMD_INDEX1_PRINT: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( Out, user_args, FILE *); ND_VA_ARG_GET( Count_Ptr, user_args, long *); ND_VA_LIST_CLOSE( user_args); DRT_Kit *Kit_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_INDEX_PRINT"; if( DR_Kit_Dump( Kit_Ptr, ++(*Count_Ptr)) != DRS_OK) { return( NDS_KO); } else { return( NDS_OK); } } case NDD_CMD_STATS_GET: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( Kit_Count_Ptr, user_args, long *); ND_VA_ARG_GET( Instrument_Count_Ptr, user_args, long *); ND_VA_ARG_GET( Layer_Count_Ptr, user_args, long *); ND_VA_ARG_GET( Sample_Count_Ptr, user_args, long *); ND_VA_LIST_CLOSE( user_args); DRT_Kit *Kit_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_STATS_GET"; (*Kit_Count_Ptr)++; return( ND_DataStruct_Traverse( Kit_Ptr->Instrument_DS_Ptr, NDD_CMD_STATS_GET, Instrument_Count_Ptr, Layer_Count_Ptr, Sample_Count_Ptr)); } case NDD_CMD_SAMPLE_LOAD: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( SampleRate, user_args, DRT_SampleRate); ND_VA_LIST_CLOSE( user_args); DRT_Kit *Kit_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_SAMPLE_LOAD"; if( DR_Kit_Sample_Load( Kit_Ptr, SampleRate) != DRS_OK) { return( NDS_KO); } else { return( NDS_OK); } } case NDD_CMD_SAMPLE_UNLOAD: { ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); DRT_Kit *Kit_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_SAMPLE_UNLOAD"; if( DR_Kit_Sample_UnLoad( Kit_Ptr) != DRS_OK) { return( NDS_KO); } else { return( NDS_OK); } } /* case NDD_CMD_PHONEBOOK_SAVE: { */ /* ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( user_data, user_args, user_type); ND_VA_ARG_GET( ..., user_args, ...); ND_VA_LIST_CLOSE( user_args); */ /* ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *); ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_ARG_GET( Out, user_args, FILE *); ND_VA_ARG_GET( Count_Ptr, user_args, long *); ND_VA_LIST_CLOSE( user_args); DRT_Kit *Kit_Ptr = Node_Ptr->Value; Command_Name = "NDD_CMD_PHONEBOOK_SAVE"; fprintf( Out, "%s:%s:%s:%s\n", Kit_Ptr->Number, Kit_Ptr->Name, Kit_Ptr->Address, Kit_Ptr->Email); (*Count_Ptr)++; return( NDS_OK); } */ default: { printf( "Kit_Manager() called with an undefined command %d\n", Command); return( NDS_ERRAPI); } } printf( "Kit_Manager() called with command %d (%s)\n", Command, Command_Name); return( NDS_OK); } /*----------------------------------------------------------------------------*/ /* DR_Layer_Add */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Layer_Add( DRT_Layer **Layer_Ptr_Ptr, NDT_Root *DS_Ptr, DRT_Layer *Layer_Template_Ptr) { NDT_Status nd_status; if( ( nd_status = ND_Value_Alloc( DS_Ptr, (void **)Layer_Ptr_Ptr, Layer_Template_Ptr)) != NDS_OK) { printf( "Can't allocate new layer: ND_Value_Alloc() failed (%d)!\n", nd_status); return( DRS_KO); } else { if( ( nd_status = ND_DataStruct_Value_Add( DS_Ptr, (void *)*Layer_Ptr_Ptr)) != NDS_OK) { printf( "Can't add new layer: ND_Value_Add() failed (%d)!\n", nd_status); return( DRS_KO); } } return( DRS_OK); } /*----------------------------------------------------------------------------*/ /* DR_Layer_Sample_Load */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Layer_Sample_Load( DRT_Layer *Layer_Ptr, DRT_Kit *Kit_Ptr, DRT_SampleRate SampleRate) { DRT_Status status; SNDFILE *sndf_ptr; // fprintf( stderr, "Loading: [%s]\n", Layer_Ptr->FileName); if( Layer_Ptr->SF_Info_Ptr != NULL) { if( Layer_Ptr->Sample_Ptr != NULL) { // fprintf( stderr, "Skiping: [%s]\n", Layer_Ptr->FileName); return( DRS_OK); } else { // fprintf( stderr, "Freeing SF_Info: [%s]\n", Layer_Ptr->FileName); free( Layer_Ptr->SF_Info_Ptr ); } } else { if( Layer_Ptr->Sample_Ptr != NULL) { // fprintf( stderr, "Freeing Sample: [%s]\n", Layer_Ptr->FileName); free( Layer_Ptr->Sample_Ptr); } } if( ( Layer_Ptr->SF_Info_Ptr = malloc( sizeof(SF_INFO))) == NULL) { fprintf( stderr, "Can't allocate SF_Info buffer!\n"); return( DRS_KO); } memset( Layer_Ptr->SF_Info_Ptr, 0, sizeof(SF_INFO)); if( ( sndf_ptr = sf_open( Layer_Ptr->FileName, SFM_READ, Layer_Ptr->SF_Info_Ptr)) == NULL) { fprintf( stderr, "Can't open sample file [%s] (%ld)!\n", Layer_Ptr->FileName, (long)sf_strerror( (SNDFILE *)( Layer_Ptr->Sample_Ptr))); status = DRS_KO; } else { if( Layer_Ptr->SF_Info_Ptr->channels > 2) { fprintf(stderr, "Too many channels: Can only handle mono / stereo samples!\n"); status = DRS_KO; } else { Layer_Ptr->Sample_Size = Layer_Ptr->SF_Info_Ptr->frames * Layer_Ptr->SF_Info_Ptr->channels; if( ( Layer_Ptr->Sample_Ptr = malloc( Layer_Ptr->Sample_Size * sizeof( float))) == NULL) { fprintf(stderr,"Can't allocate sample memory: (%ld) for [%s]!\n", Layer_Ptr->Sample_Size, Layer_Ptr->FileName); status = DRS_KO; } else { sf_read_float( sndf_ptr, Layer_Ptr->Sample_Ptr, ( Layer_Ptr->Sample_Size)); status = DRS_OK; // convert rate if needed if( Layer_Ptr->SF_Info_Ptr->samplerate != SampleRate) { int src_status; SRC_DATA src_data; long out_size; // fprintf( stderr, "Resampling: [%s] (%d)->(%d)\n", Layer_Ptr->FileName, Layer_Ptr->SF_Info_Ptr->samplerate, SampleRate); src_data.data_in = Layer_Ptr->Sample_Ptr; src_data.input_frames = Layer_Ptr->SF_Info_Ptr->frames; src_data.src_ratio = (double)SampleRate / Layer_Ptr->SF_Info_Ptr->samplerate; src_data.output_frames = (long)ceil( Layer_Ptr->SF_Info_Ptr->frames * src_data.src_ratio); out_size = src_data.output_frames * Layer_Ptr->SF_Info_Ptr->channels * sizeof( float); if( ( src_data.data_out = malloc( out_size)) == NULL) { fprintf( stderr,"Can't allocate resample memory: (%ld) for [%s]!\n", out_size, Layer_Ptr->FileName); status = DRS_KO; } else { if( ( src_status = src_simple( &src_data, DRD_RATE_CONV_QUALITY, Layer_Ptr->SF_Info_Ptr->channels)) != 0) { fprintf( stderr,"Can't convert rate for [%s]: [%s]\n", Layer_Ptr->FileName, src_strerror( src_status)); free( src_data.data_out); } else { if( src_data.input_frames_used != Layer_Ptr->SF_Info_Ptr->frames) { fprintf(stderr,"Didn't consume all input frames. used: %li had: %li gened: %li\n", src_data.input_frames_used, Layer_Ptr->SF_Info_Ptr->frames, src_data.output_frames_gen); } free( Layer_Ptr->Sample_Ptr); Layer_Ptr->Sample_Ptr = src_data.data_out; Layer_Ptr->Sample_Size = src_data.output_frames_gen * Layer_Ptr->SF_Info_Ptr->channels; Layer_Ptr->SF_Info_Ptr->samplerate = SampleRate; Layer_Ptr->SF_Info_Ptr->frames = src_data.output_frames_gen; } } } } } sf_close( sndf_ptr); } return( status); } /*----------------------------------------------------------------------------*/ /* DR_Layer_Sample_UnLoad */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Layer_Sample_UnLoad( DRT_Layer *Layer_Ptr) { // fprintf( stderr, "UnLoading: [%s]\n", Layer_Ptr->FileName); if( Layer_Ptr->Sample_Ptr != NULL) { // fprintf( stderr, "Freeing Sample!\n"); free( Layer_Ptr->Sample_Ptr); } if( Layer_Ptr->SF_Info_Ptr != NULL) { // fprintf( stderr, "Freeing SF_Info!\n"); free( Layer_Ptr->SF_Info_Ptr); } return( NDS_OK); } /*----------------------------------------------------------------------------*/ /* DR_Layer_Dump */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Layer_Dump( DRT_Layer *Layer_Ptr, long count) { NDT_Status nd_status; fprintf( stderr, " %03ld) Layer: ", count); fprintf( stderr, " Id: (% 3d) File Name: [%s] Sample: [%lx] Sample Size: (%ld) Min: (%f) Max: (%f) Gain: (%f) Pitch: (%f)", Layer_Ptr->Id, Layer_Ptr->FileName, (long)Layer_Ptr->Sample_Ptr, Layer_Ptr->Sample_Size, Layer_Ptr->Min, Layer_Ptr->Max, Layer_Ptr->Gain, Layer_Ptr->Pitch); if( Layer_Ptr->SF_Info_Ptr != NULL) { fprintf( stderr, " Channels: (%d) Rate: (%d)\n", Layer_Ptr->SF_Info_Ptr->channels, Layer_Ptr->SF_Info_Ptr->samplerate); } else { fprintf( stderr, "\n"); } return( DRS_OK); } /*----------------------------------------------------------------------------*/ /* DR_Instrument_Add */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Instrument_Add( DRT_Instrument **Instrument_Ptr_Ptr, NDT_Root *DS_Ptr, DRT_Instrument *Instrument_Template_Ptr) { NDT_Status nd_status; if( ( nd_status = ND_Value_Alloc( DS_Ptr, (void **)Instrument_Ptr_Ptr, Instrument_Template_Ptr)) != NDS_OK) { printf( "Can't allocate new instrument: ND_Value_Alloc() failed (%d)!\n", nd_status); return( DRS_KO); } else { if( ( nd_status = ND_DataStruct_Value_Add( DS_Ptr, (void *)*Instrument_Ptr_Ptr)) != NDS_OK) { printf( "Can't add new instrument: ND_Value_Add() failed (%d)!\n", nd_status); return( DRS_KO); } } return( DRS_OK); } /*----------------------------------------------------------------------------*/ /* DR_Instrument_Dump */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Instrument_Dump( DRT_Instrument *Instrument_Ptr, long Count) { NDT_Status nd_status; long count2; fprintf( stderr, " %03ld) Instrument: ", Count); fprintf( stderr, " Id: (% 3d) Name: [%s] Gain: (%f) Pan Left: (%f) Pan Right: (%f)\n", Instrument_Ptr->Id, Instrument_Ptr->Name, Instrument_Ptr->Gain, Instrument_Ptr->Pan_Left, Instrument_Ptr->Pan_Right); // fprintf( stderr, "\n"); fprintf( stderr, " Layer List:\n"); if( Instrument_Ptr->Layer_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number == 0) { fprintf( stderr, " Empty list!\n"); } else { count2 = 0; if( ( nd_status = ND_DataStruct_Value_Print( stderr, Instrument_Ptr->Layer_DS_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0, &count2)) != NDS_OK) { printf( "Cant't dump layers: ND_DataStruct_Traverse() failed (%d)!\n", nd_status); return( DRS_KO); } } fprintf( stderr, "\n"); return( DRS_OK); } /*----------------------------------------------------------------------------*/ /* DR_Kit_Add */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Kit_Add( DRT_Kit **Kit_Ptr_Ptr, NDT_Root *DS_Ptr, DRT_Kit *Kit_Template_Ptr) { NDT_Status nd_status; if( ( nd_status = ND_Value_Alloc( DS_Ptr, (void **)Kit_Ptr_Ptr, Kit_Template_Ptr)) != NDS_OK) { printf( "Can't allocate new kit: ND_Value_Alloc() failed (%d)!\n", nd_status); return( DRS_KO); } else { if( ( nd_status = ND_DataStruct_Value_Add( DS_Ptr, (void **)*Kit_Ptr_Ptr)) != NDS_OK) { printf( "Can't add new kit: ND_Value_Add() failed (%d)!\n", nd_status); return( DRS_KO); } } return( DRS_OK); } /*----------------------------------------------------------------------------*/ /* DR_Kit_Id_Find */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Kit_Id_Find( DRT_Kit **Kit_Ptr_Ptr, NDT_Root *DS_Ptr, DRT_Kit_Id Kit_Id) { DRT_Status status; NDT_Status nd_status; DRT_Kit kit_template; kit_template.Id = Kit_Id; kit_template.Name[0] = '\0'; if( ( nd_status = ND_DataStruct_Value_Find( (void **)Kit_Ptr_Ptr, DS_Ptr, &kit_template)) != NDS_OK) { fprintf( stderr, "DR_Kit_Id_Find: Find error: (%d)!\n", nd_status); status = DRS_KO; } else { if( *Kit_Ptr_Ptr == NULL) { fprintf( stderr, "Can't find: Kit with id: (%ld)!\n", Kit_Id); status = DRS_KO; } else { status = DRS_OK; } } return( status); } /*----------------------------------------------------------------------------*/ /* DR_Kit_Name_Find */ /*----------------------------------------------------------------------------*/ extern DRT_Status DR_Kit_Name_Find( DRT_Kit **Kit_Ptr_Ptr, NDT_Root *DS_Ptr, char *Kit_Name) { DRT_Status status; NDT_Status nd_status; DRT_Kit kit_template; kit_template.Id = 1; strncpy( kit_template.Name, Kit_Name, DRD_NAME_LEN); if( ( nd_status = ND_DataStruct_Value_Find( (void **)Kit_Ptr_Ptr, DS_Ptr, &kit_template)) != NDS_OK) { fprintf( stderr, "DR_Kit_Name_Find: Find error: (%d)!\n", nd_status); status = DRS_KO; } else { if( *Kit_Ptr_Ptr == NULL) { fprintf( stderr, "Can't find: Kit with name: [%s]!\n", Kit_Name); status = DRS_KO; } else { status = DRS_OK; } } return( status); } /*----------------------------------------------------------------------------*/ /* DR_Kit_Dump */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Kit_Dump( DRT_Kit *Kit_Ptr, long Count) { NDT_Status nd_status; long count2; fprintf( stderr, " %03ld) DrumKit:", Count); fprintf( stderr, " Id: (% 3d) Status: [%s] Name: [%s] Descrition: [%.32s] Dir Name: [%s]\n", Kit_Ptr->Id, DR_LOAD_STATUS_ASCII_GET( Kit_Ptr), Kit_Ptr->Name, Kit_Ptr->Desc, Kit_Ptr->DirName); fprintf( stderr, " Instruments List:\n"); if( Kit_Ptr->Instrument_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number == 0) { fprintf( stderr, " Empty list!\n"); } else { count2 = 0; if( ( nd_status = ND_DataStruct_Value_Print( stderr, Kit_Ptr->Instrument_DS_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0, &count2)) != NDS_OK) { printf( "Cant't dump intruments: ND_DataStruct_Traverse() failed (%d)!\n", nd_status); return( DRS_KO); } } fprintf( stderr, "\n"); return( DRS_OK); } /*----------------------------------------------------------------------------*/ /* DR_XML_Node_Exist */ /*----------------------------------------------------------------------------*/ DRT_Status DR_XML_Node_Exist( xmlDocPtr Xml_Doc, xmlXPathContextPtr Xml_XpathCtx, char *Xpath_Request) { DRT_Status status; xmlXPathObjectPtr xml_xpathobj; xmlNodeSetPtr nodeset; char *tmpval_ptr; long tmpval_len; if( ( xml_xpathobj = xmlXPathEvalExpression( (xmlChar *)Xpath_Request, Xml_XpathCtx)) == NULL) { fprintf( stderr, "DR_XML_Node_Exist: xmlXPathEvalExpression failed [%s]!\n", Xpath_Request); status = DRS_KO; } else { nodeset = xml_xpathobj->nodesetval; if( xmlXPathNodeSetIsEmpty( nodeset)) { // fprintf( stderr, "[%s] not found!\n", Xpath_Request); status = DRS_KO; } else { // fprintf( stderr, "[%s] found!\n", Xpath_Request); status = DRS_OK; } } xmlXPathFreeObject( xml_xpathobj); return( status); } /*----------------------------------------------------------------------------*/ /* DR_XML_Value_Get */ /*----------------------------------------------------------------------------*/ DRT_Status DR_XML_Value_Get( char *Value_Ptr, long Max_Len, xmlDocPtr Xml_Doc, xmlXPathContextPtr Xml_XpathCtx, char *Xpath_HeadRequest, char *Xpath_TailRequest) { DRT_Status status; xmlXPathObjectPtr xml_xpathobj; xmlNodeSetPtr nodeset; char *tmpval_ptr; long tmpval_len; char xpath_request[1024]; strcpy( xpath_request, Xpath_HeadRequest); strcat( xpath_request, Xpath_TailRequest); if( ( xml_xpathobj = xmlXPathEvalExpression( (xmlChar *)xpath_request, Xml_XpathCtx)) == NULL) { fprintf( stderr, "DR_XML_Value_Get: xmlXPathEvalExpression failed! [%s]\n", xpath_request); status = DRS_KO; } else { nodeset = xml_xpathobj->nodesetval; if( xmlXPathNodeSetIsEmpty( nodeset)) { fprintf( stderr, "[%s] not found!\n", xpath_request); status = DRS_KO; } else { if( ( tmpval_ptr = (char *)xmlNodeListGetString( Xml_Doc, nodeset->nodeTab[0]->xmlChildrenNode, 1)) == NULL) { fprintf( stderr, "[%s] value not found!\n", xpath_request); status = DRS_KO; } else { // fprintf( stderr, "[%s] = [%s] found!\n", nodeset->nodeTab[0]->name, tmpval_ptr); if( ( tmpval_len = strlen( tmpval_ptr)) > Max_Len) { fprintf( stderr, "Value too long (%ld)>(%ld)!\n", tmpval_len, Max_Len); status = DRS_OK; } else { strcpy( Value_Ptr, tmpval_ptr); status = DRS_OK; } } xmlFree( tmpval_ptr); } } xmlXPathFreeObject( xml_xpathobj); return( status); } /*----------------------------------------------------------------------------*/ /* DR_XML_Query_Tab_Exec */ /*----------------------------------------------------------------------------*/ DRT_Status DR_XML_Query_Tab_Exec( void *Value_Ptr, xmlDocPtr XML_Doc, xmlXPathContextPtr XML_XpathCtx, char *Xpath_Head, DRT_XML_Query *XML_Query_Tab) { DRT_Status status; char reply_str[DRD_DESC_SIZE]; int i; i=0; while( XML_Query_Tab[i].XPath_Query != NULL) { if( ( status = DR_XML_Value_Get( reply_str, DRD_DESC_LEN, XML_Doc, XML_XpathCtx, Xpath_Head, XML_Query_Tab[i].XPath_Query)) != DRS_OK) { strcpy( reply_str, ""); } switch( XML_Query_Tab[i].Value_Type) { case DRD_XML_QUERY_VALUE_STRING: { strncpy( ( Value_Ptr + XML_Query_Tab[i].Value_Offset), reply_str, XML_Query_Tab[i].Value_Len); break; } case DRD_XML_QUERY_VALUE_INT: { *( (int *)( Value_Ptr + XML_Query_Tab[i].Value_Offset)) = atoi( reply_str); break; } case DRD_XML_QUERY_VALUE_LONG: { *( (long *)( Value_Ptr + XML_Query_Tab[i].Value_Offset)) = strtol( reply_str, NULL, 10); break; } case DRD_XML_QUERY_VALUE_LONGLONG: { *( (long long *)( Value_Ptr + XML_Query_Tab[i].Value_Offset)) = strtoll( reply_str, NULL, 10); break; } case DRD_XML_QUERY_VALUE_FLOAT: { *( (float *)( Value_Ptr + XML_Query_Tab[i].Value_Offset)) = strtof( reply_str, NULL); break; } case DRD_XML_QUERY_VALUE_DOUBLE: { *( (double *)( Value_Ptr + XML_Query_Tab[i].Value_Offset)) = strtod( reply_str, NULL); break; } default: { fprintf( stderr, "Unknown valute type: (%d)\n", XML_Query_Tab[i].Value_Type); break; } } i++; } return( DRS_OK); } /*----------------------------------------------------------------------------*/ /* DR_Kit_Load */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Kit_Load( DRT_Base *Base_Ptr, char *FileName) { DRT_Status status; NDT_Status nd_status; DRT_Kit kit_template; DRT_Kit *kit_ptr; DRT_Instrument instrument_template; DRT_Instrument *instrument_ptr; DRT_Layer layer_template; DRT_Layer *layer_ptr; xmlDocPtr xml_doc; xmlXPathContextPtr xml_xpathCtx; xmlXPathObjectPtr xml_xpathObj; char tmp_filename[DRD_FILENAME_SIZE]; char xpath_head[1024]; char reply_str[256]; int instrument, layer; short i; kit_template.Status = DRD_LOAD_STATUS_UNLOADED; layer_template.Sample_Ptr = NULL; layer_template.Sample_Size = 0; layer_template.SF_Info_Ptr = NULL; fprintf( stderr, "Loading: [%s]...\n", FileName); if( strlen( FileName) > DRD_FILENAME_LEN) { fprintf( stderr, "Kit file name too long [%s]!", FileName); status = DRS_KO; } else { strcpy( tmp_filename, FileName); strcpy( kit_template.DirName, dirname(tmp_filename)); if( ( xml_doc = xmlParseFile( FileName)) == NULL) { fprintf( stderr, "xml_doc failed!\n"); status = DRS_KO; } else { if( ( xml_xpathCtx = xmlXPathNewContext( xml_doc)) == NULL) { fprintf( stderr, "xmlXPathNewContext failed!\n"); status = DRS_KO; } else { if( xmlXPathRegisterNs( xml_xpathCtx, (xmlChar *)"drumkit", (xmlChar *)"http://www.hydrogen-music.org/drumkit") != 0) { fprintf( stderr,"Error: unable to register default NS!\n"); status = DRS_KO; } if( ( status = DR_XML_Node_Exist( xml_doc, xml_xpathCtx, DRD_XML_XPATH_DRUMKIT_BASE_STR) != DRS_OK)) { fprintf( stderr, "Bad drumkit file!\n"); } else { DR_XML_Query_Tab_Exec( &kit_template, xml_doc, xml_xpathCtx, DRD_XML_XPATH_DRUMKIT_BASE_STR, DRG_XML_Query_Tab_Kit); if( ( status = DR_Kit_Add( &kit_ptr, Base_Ptr->Kit_DS_Ptr, &kit_template)) != DRS_OK) { fprintf( stderr, "Can't create a new kit!\n"); } else { // fprintf( stderr, "New kit!\n"); status = DRS_OK; instrument = 1; while( ( status == DRS_OK) && ( sprintf( xpath_head, DRD_XML_XPATH_DRUMKIT_INSTRUMENT_FULL, instrument) > 0) && ( DR_XML_Node_Exist( xml_doc, xml_xpathCtx, xpath_head) == DRS_OK)) { instrument_template.Id = -1; DR_XML_Query_Tab_Exec( &instrument_template, xml_doc, xml_xpathCtx, xpath_head, DRG_XML_Query_Tab_Instrument); if( instrument_template.Id == -1) { fprintf( stderr, "Instrument id not found!\n"); } else { if( ( status = DR_Instrument_Add( &instrument_ptr, kit_ptr->Instrument_DS_Ptr, &instrument_template)) != DRS_OK) { fprintf( stderr, "Can't create a new instrument!\n"); } else { // fprintf( stderr, "New Instrument!\n"); } layer = 1; while( ( status == DRS_OK) && ( sprintf( xpath_head, DRD_XML_XPATH_DRUMKIT_LAYER_FULL, instrument, layer) > 0) && ( DR_XML_Node_Exist( xml_doc, xml_xpathCtx, xpath_head) == DRS_OK)) { DR_XML_Query_Tab_Exec( &layer_template, xml_doc, xml_xpathCtx, xpath_head, DRG_XML_Query_Tab_Layer); strcpy( tmp_filename, kit_template.DirName); strcat( tmp_filename, "/"); strcat( tmp_filename, layer_template.FileName); strcpy( layer_template.FileName, tmp_filename); if( ( status = DR_Layer_Add( &layer_ptr, instrument_ptr->Layer_DS_Ptr, &layer_template)) != DRS_OK) { fprintf( stderr, "Can't create a new layer!\n"); } else { // fprintf( stderr, "New layer!\n"); layer++; } } } instrument++; } } } xmlXPathFreeContext( xml_xpathCtx); } xmlFreeDoc( xml_doc); } } xmlCleanupParser(); return( status); } /*----------------------------------------------------------------------------*/ /* DR_Kit_Sample_Load */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Kit_Sample_Load( DRT_Kit *Kit_Ptr, DRT_SampleRate SampleRate) { NDT_Status nd_status; if( DR_LOAD_STATUS_LOADED_IS( Kit_Ptr)) { fprintf( stderr, "Loading kit samples: [%s] Skiped!\n", Kit_Ptr->Name); } else { fprintf( stderr, "Loading kit samples: [%s]!\n", Kit_Ptr->Name); if( ( nd_status = ND_DataStruct_Traverse( Kit_Ptr->Instrument_DS_Ptr, NDD_CMD_SAMPLE_LOAD, Kit_Ptr, SampleRate)) != NDS_OK) { printf( "Cant't load kit samples: ND_DataStruct_Traverse() failed (%d)!\n", nd_status); return( DRS_KO); } Kit_Ptr->Status = DRD_LOAD_STATUS_LOADED; } return( DRS_OK); } /*----------------------------------------------------------------------------*/ /* DR_Kit_Sample_UnLoad */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Kit_Sample_UnLoad( DRT_Kit *Kit_Ptr) { NDT_Status nd_status; if( !DR_LOAD_STATUS_LOADED_IS( Kit_Ptr)) { fprintf( stderr, "UnLoading kit samples: [%s] Skiped!\n", Kit_Ptr->Name); } else { fprintf( stderr, "UnLoading kit samples: [%s]!\n", Kit_Ptr->Name); if( ( nd_status = ND_DataStruct_Traverse( Kit_Ptr->Instrument_DS_Ptr, NDD_CMD_SAMPLE_UNLOAD, Kit_Ptr)) != NDS_OK) { printf( "Cant't unload kit samples: ND_DataStruct_Traverse() failed (%d)\n", nd_status); return( DRS_KO); } Kit_Ptr->Status = DRD_LOAD_STATUS_UNLOADED; } return( DRS_OK); } /*----------------------------------------------------------------------------*/ /* DR_DataStruct_Init */ /*----------------------------------------------------------------------------*/ DRT_Status DR_DataStruct_Init( DRT_Base *Base_Ptr, DRT_SampleRate SampleRate) { NDT_Status nd_status; if( ( nd_status = ND_Library_Open( NDD_TRUE)) != NDS_OK) { fprintf( stderr, "Can't open node library (%d)!\n", nd_status); return( DRS_KO); } if( ( nd_status = ND_DataStruct_Open( &(Base_Ptr->Kit_DS_Ptr), DRD_KIT_DS_INDEX_NB, DRG_Kit_DS_Index_Tab_Initial, "Kit_Manager", DR_Kit_Manager, NULL, NULL, NULL, NULL, NDD_TRUE, NULL)) != NDS_OK) { printf( "Kit_DS: ND_DataStruct_Open() failed (%d)!\n", nd_status); return( DRS_KO); } Base_Ptr->SampleRate = SampleRate; return( DRS_OK); } /*----------------------------------------------------------------------------*/ /* DR_DataStruct_DeInit */ /*----------------------------------------------------------------------------*/ DRT_Status DR_DataStruct_DeInit( DRT_Base *Base_Ptr) { NDT_Status nd_status; if( ( nd_status = ND_DataStruct_Close( Base_Ptr->Kit_DS_Ptr)) != NDS_OK) { printf( "Can't close Kit_DS (%d)!\n", nd_status); return( DRS_KO); } if( ( nd_status = ND_Library_Close()) != NDS_OK) { fprintf( stderr, "Can't close node library (%d)!\n", nd_status); return( DRS_KO); } return( DRS_OK); } /*----------------------------------------------------------------------------*/ /* DR_Kits_Sample_Load */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Kits_Sample_Load( DRT_Base *Base_Ptr) { NDT_Status nd_status; fprintf( stderr, "Loading kits samples!\n"); if( ( nd_status = ND_DataStruct_Traverse( Base_Ptr->Kit_DS_Ptr, NDD_CMD_SAMPLE_LOAD, Base_Ptr->SampleRate)) != NDS_OK) { printf( "Cant't load kit samples: ND_DataStruct_Traverse() failed (%d)!\n", nd_status); return( DRS_KO); } return( DRS_OK); } /*----------------------------------------------------------------------------*/ /* DR_Kits_Sample_UnLoad */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Kits_Sample_UnLoad( DRT_Base *Base_Ptr) { NDT_Status nd_status; fprintf( stderr, "UnLoading kits samples!\n"); if( ( nd_status = ND_DataStruct_Traverse( Base_Ptr->Kit_DS_Ptr, NDD_CMD_SAMPLE_UNLOAD, Base_Ptr->SampleRate)) != NDS_OK) { printf( "Cant't unload kit samples: ND_DataStruct_Traverse() failed (%d)!\n", nd_status); return( DRS_KO); } return( DRS_OK); } /*----------------------------------------------------------------------------*/ /* DR_Kits_Load */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Kits_Load( DRT_Base *Base_Ptr) { DRT_Status status; NDT_Status nd_status; char glob_pattern[] = "~/.hydrogen/data/drumkits/*/drumkit.xml"; // char glob_pattern[] = "~/.hydrogen/data/drumkits/AVL-BlackPearl-4A-1.1/drumkit.xml"; // char glob_pattern[] = "~/.hydrogen/data/drumkits/Mars Lindrum: 02-Kit 2/drumkit.xml"; // char glob_pattern[] = "~/.hydrogen/data/drumkits/Mars Mod */drumkit.xml"; glob_t glob_struct; int i; LIBXML_TEST_VERSION; if( glob( glob_pattern, (GLOB_NOSORT + GLOB_TILDE), NULL, &glob_struct) != 0) { fprintf( stderr, "glob() error!\n"); status = DRS_KO; } else { for( i = 0; i < glob_struct.gl_pathc; i++) { // printf( "[%s]\n", glob_struct.gl_pathv[i]); if( ( status = DR_Kit_Load( Base_Ptr, glob_struct.gl_pathv[i])) != DRS_OK) { fprintf( stderr, "Can't load kit [%s]!\n", glob_struct.gl_pathv[i]); } } if( ( nd_status = ND_DataStruct_Convert( Base_Ptr->Kit_DS_Ptr, DRG_Kit_DS_Index_Tab_Final)) != NDS_OK) { fprintf( stderr, "ND_DataStruct_Convert() failed (%d)!\n", status); status = DRS_KO; } else { status = DRS_OK; } } globfree( &glob_struct); // Base_Ptr->SampleRate=44100; /* status = DR_Layer_Sample_Load( (DRT_Layer *)( ((DRT_Instrument *)( ((DRT_Kit *)(Base_Ptr->Kit_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Head->Value)) ->Instrument_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Head->Value)) ->Layer_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Head->Value), (DRT_Kit *)(Base_Ptr->Kit_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Head->Value), Base_Ptr->SampleRate); */ /* if( Base_Ptr->Kit_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Head != NULL) { status = DR_Kit_Sample_Load( (DRT_Kit *)(Base_Ptr->Kit_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Head->Value), Base_Ptr->SampleRate); } */ // status = DR_Kits_Sample_Load( Base_Ptr); return( status); } /*----------------------------------------------------------------------------*/ /* DR_Kits_Dump */ /*----------------------------------------------------------------------------*/ DRT_Status DR_Kits_Dump( DRT_Base *Base_Ptr) { NDT_Status nd_status; short index; long count = 0; long kit_count = 0; long instrument_count = 0; long layer_count = 0; long sample_count = 0; fprintf( stderr, "\n"); fprintf( stderr, "Sample Rate: (%d)\n", Base_Ptr->SampleRate); fprintf( stderr, "DrumKit List:\n"); /* if( ( nd_status = ND_DataStruct_Info_Print( stderr, Base_Ptr->Kit_DS_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0)) != NDS_OK) { printf( "ND_DataStruct_Info_Print() failed (%d)!\n", nd_status); return( DRS_KO); } for( index = 0; index < Base_Ptr->Kit_DS_Ptr->Index_Nb; index++) { count = 0; fprintf( stderr, "Dump Index: (%d)\n", index); if( Base_Ptr-> Kit_DS_Ptr->Index_Tab[index].Node_Number == 0) { fprintf( stderr, " Empty list!\n"); } else { if( ( nd_status = ND_DataStruct_Traverse( Base_Ptr->Kit_DS_Ptr, (NDD_CMD_INDEX0_PRINT + index), stderr, &count)) != NDS_OK) { printf( "Can't dump kits: ND_DataStruct_Traverse() failed (%d)!\n", nd_status); return( DRS_KO); } } fprintf( stderr, "\n"); } */ if( ( nd_status = ND_DataStruct_Value_Print( stderr, Base_Ptr->Kit_DS_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0, &count)) != NDS_OK) { printf( "Can't dump kits: ND_DataStruct_Value_Print() failed (%d)!\n", nd_status); return( DRS_KO); } if( ( nd_status = ND_DataStruct_Traverse( Base_Ptr->Kit_DS_Ptr, NDD_CMD_STATS_GET, &kit_count, &instrument_count, &layer_count, &sample_count)) != NDS_OK) { printf( "Can't compute stats: ND_DataStruct_Traverse() failed (%d)!\n", nd_status); return( DRS_KO); } fprintf( stderr, "Number of Kits: (%ld) Number of Instruments: (%ld) Number of Layers: (%ld) Number of Loaded Samples: (%ld)\n", kit_count, instrument_count, layer_count, sample_count); return( DRS_OK); }