From 6be9e0f582643b4b9c93a75e38eaec6b00b07192 Mon Sep 17 00:00:00 2001 From: "Arnaud G. GIBERT" Date: Sun, 27 Mar 2022 11:33:37 +0200 Subject: [PATCH] - Fix memory leaks with valgrind! - Move data structure management in datastruct.c and datastruct.h files, - Prepare LV2 plugin in new lv2_plugin.c and lv2_plugin.h files. --- datastruct.c | 1952 ++++++++++++++++++++++++++++++++++++++++++++++++++ datastruct.h | 495 +++++++++++++ lv2_plugin.c | 24 + lv2_plugin.h | 325 +++++++++ 4 files changed, 2796 insertions(+) create mode 100644 datastruct.c create mode 100644 datastruct.h create mode 100644 lv2_plugin.c create mode 100644 lv2_plugin.h diff --git a/datastruct.c b/datastruct.c new file mode 100644 index 0000000..af42fe9 --- /dev/null +++ b/datastruct.c @@ -0,0 +1,1952 @@ +/*---------------------------------------------------------------------------------*/ +/* 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, 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)->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"; + + + if( Layer_Ptr->Sample_Ptr != NULL) + { + free(Layer_Ptr->Sample_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, double); + + 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); + } + 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, 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, double); + + 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)); + } + + 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_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; + + strncpy( ( *Kit_Ptr_Ptr)->Name, Kit_Template_Ptr->Name, NAME_SIZE); + strncpy( ( *Kit_Ptr_Ptr)->Desc, Kit_Template_Ptr->Desc, DESC_SIZE); + strncpy( ( *Kit_Ptr_Ptr)->DirName, Kit_Template_Ptr->DirName, 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, double); + + ND_VA_LIST_CLOSE( user_args); + + DRT_Kit *Kit_Ptr = Node_Ptr->Value; + + + Command_Name = "NDD_CMD_SAMPLE_LOAD"; + + return( ND_DataStruct_Traverse( Kit_Ptr->Instrument_DS_Ptr, NDD_CMD_SAMPLE_LOAD, Kit_Ptr, SampleRate)); + } + +/* + 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, double SampleRate) +{ + DRT_Status status; + SNDFILE *sndf_ptr; + +// int load_sample(char* path, drmr_layer* layer, double target_rate) { +// long size; + + + fprintf( stderr, "Loading: [%s]\n", Layer_Ptr->FileName); + + 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] (%d)!\n", Layer_Ptr->FileName, 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 * sizeof( float); + + if( ( Layer_Ptr->Sample_Ptr = malloc( Layer_Ptr->Sample_Size)) == NULL) + { + fprintf(stderr,"Can't allocate sample memory: (%d) 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 / sizeof( float))); + + 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; + + + src_data.data_in = Layer_Ptr->Sample_Ptr; + src_data.input_frames = Layer_Ptr->SF_Info_Ptr->frames; + src_data.src_ratio = 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: (%d) for [%s]!\n", out_size, Layer_Ptr->FileName); + status = DRS_KO; + } + else + { + + if( ( src_status = src_simple( &src_data, 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 * sizeof( float); + Layer_Ptr->SF_Info_Ptr->samplerate = SampleRate; + Layer_Ptr->SF_Info_Ptr->frames = src_data.output_frames_gen; + } + } + } + } + } + + sf_close( sndf_ptr); + } + + free( Layer_Ptr->SF_Info_Ptr); + + return( status); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* DR_Layer_Sample_UnLoad */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_Layer_Sample_UnLoad( DRT_Layer *Layer_Ptr) +{ +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* DR_Layer_Dump */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_Layer_Dump( DRT_Layer *Layer_Ptr, long count) +{ + NDT_Status nd_status; + + + fprintf( stderr, " %03d) Layer: ", count); + fprintf( stderr, " Id: (% 3d) File Name: [%s] Sample: [%lx] Sample Size: (%d) Min: (%f) Max: (%f) Gain: (%f) Pitch: (%f)\n", + Layer_Ptr->Id, Layer_Ptr->FileName, Layer_Ptr->Sample_Ptr, Layer_Ptr->Sample_Size, Layer_Ptr->Min, Layer_Ptr->Max, Layer_Ptr->Gain, Layer_Ptr->Pitch); +// 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, " %03d) 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_Sample_Load */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_Kit_Sample_Load( DRT_Kit *Kit_Ptr, double SampleRate) +{ + NDT_Status nd_status; + + + 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); + } + + return( DRS_OK); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* DR_Kit_Dump */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_Kit_Dump( DRT_Kit *Kit_Ptr, long Count) +{ + NDT_Status nd_status; + long count2; + + + + fprintf( stderr, " %03d) DrumKit:", Count); + fprintf( stderr, " Id: (% 3d) Name: [%s] Descrition: [%.32s] Dir Name: [%s]\n", Kit_Ptr->Id, 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( 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( 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 = 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 (%d)>(%d)!\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[DESC_SIZE]; + int i; + + + i=0; + + while( XML_Query_Tab[i].XPath_Query != NULL) + { + if( ( status = DR_XML_Value_Get( reply_str, 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 XML_QUERY_VALUE_STRING: + { + strncpy( ( Value_Ptr + XML_Query_Tab[i].Value_Offset), reply_str, XML_Query_Tab[i].Value_Len); + break; + } + + case XML_QUERY_VALUE_INT: + { + *( (int *)( Value_Ptr + XML_Query_Tab[i].Value_Offset)) = atoi( reply_str); + break; + } + + case XML_QUERY_VALUE_LONG: + { + *( (long *)( Value_Ptr + XML_Query_Tab[i].Value_Offset)) = strtol( reply_str, NULL, 10); + break; + } + + case XML_QUERY_VALUE_LONGLONG: + { + *( (long long *)( Value_Ptr + XML_Query_Tab[i].Value_Offset)) = strtoll( reply_str, NULL, 10); + break; + } + + case XML_QUERY_VALUE_FLOAT: + { + *( (float *)( Value_Ptr + XML_Query_Tab[i].Value_Offset)) = strtof( reply_str, NULL); + break; + } + + case 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[FILENAME_SIZE]; + char xpath_head[1024]; + char reply_str[256]; + + int instrument, layer; + short i; + + + layer_template.Sample_Ptr = NULL; + layer_template.Sample_Size = 0; + + + fprintf( stderr, "Loading: [%s]...\n", FileName); + + if( strlen( FileName) > 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, "drumkit", "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, 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, 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, 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, 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_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"; + 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); +*/ +/* + status = DR_Kit_Sample_Load( (DRT_Kit *)(Base_Ptr->Kit_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Head->Value), + Base_Ptr->SampleRate); +*/ + + 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( 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, "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); +} + + + + + +/*---------------------------------------------------------------------------------*/ +/* DR_DataStruct_Init */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_DataStruct_Init( DRT_Base *Base_Ptr) +{ + NDT_Status nd_status; + + + if( ( nd_status = ND_Library_Open( NDD_TRUE)) != NDS_OK) + { + fprintf( stderr, "Can't open node library (%d) !", 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); + } + + 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)!", nd_status); + return( DRS_KO); + } + + return( DRS_OK); +} diff --git a/datastruct.h b/datastruct.h new file mode 100644 index 0000000..2a79b15 --- /dev/null +++ b/datastruct.h @@ -0,0 +1,495 @@ +/*---------------------------------------------------------------------------------*/ +/* Includes */ +/*---------------------------------------------------------------------------------*/ + +#ifndef _DATASTRUCT_H_ +#define _DATASTRUCT_H_ + + + + + + + + + + + +/*----------------------------------------------------------------------------*/ +/* Global definitions */ +/*----------------------------------------------------------------------------*/ + +typedef short DRT_Boolean; + +#define DRD_FALSE ( DRT_Boolean) 0 +#define DRD_TRUE ( DRT_Boolean) 1 + +#define DRD_NO 'n' +#define DRD_YES 'y' + +#define DRD_MAX(A,B) (((A) < (B)) ? (B) : (A)) +#define DRD_MIN(A,B) (((A) > (B)) ? (B) : (A)) + +#define NDD_CMD_STATS_GET ( NDT_Command) 65 +#define NDD_CMD_SAMPLE_LOAD ( NDT_Command) 66 +#define NDD_CMD_SAMPLE_UNLOAD ( NDT_Command) 67 +#define NDD_CMD_INDEX0_PRINT ( NDT_Command) 68 +#define NDD_CMD_INDEX1_PRINT ( NDT_Command) 69 + +#define NAME_LEN (short) 256 +#define NAME_SIZE (NAME_LEN + 1) +#define DIRNAME_LEN (short) 1024 +#define DIRNAME_SIZE (DIRNAME_LEN) +#define FILENAME_LEN (short) 1024 +#define FILENAME_SIZE (FILENAME_LEN) +#define DESC_LEN (short) 4096 +#define DESC_SIZE (DESC_LEN + 1) + + + + + +/*---------------------------------------------------------------------------------*/ +/* Layer / Instrument / Kit */ +/*---------------------------------------------------------------------------------*/ + +typedef struct DRT_Layer +{ + short Id; + char FileName[ FILENAME_SIZE]; + float *Sample_Ptr; + long Sample_Size; + SF_INFO *SF_Info_Ptr; + double Min; + double Max; + double Gain; + double Pitch; +} DRT_Layer; + + + +typedef struct DRT_Instrument +{ + short Id; + char Name[ NAME_SIZE]; + double Gain; + double Pan_Left; + double Pan_Right; + NDT_Root *Layer_DS_Ptr; +} DRT_Instrument; + + + +typedef struct DRT_Kit +{ + short Id; + char Name[ NAME_SIZE]; + char Desc[ DESC_SIZE]; + char DirName[ DIRNAME_SIZE]; + NDT_Root *Instrument_DS_Ptr; +} DRT_Kit; + + + + + +# ifdef _DATASTRUCT_C_ + +/*----------------------------------------------------------------------------*/ +/* Private Definitions */ +/*----------------------------------------------------------------------------*/ + +/*----------------------------------------------------------------------------*/ +/* Layer_DS Indexes */ +/*----------------------------------------------------------------------------*/ + +#define DRD_LAYER_DS_INDEX_NB (short)2 + +static NDT_Index_Type DRG_Layer_DS_Index_Tab_Initial[DRD_LAYER_DS_INDEX_NB] = +{ + (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED), + (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED) +}; + +static NDT_Index_Type DRG_Layer_DS_Index_Tab_Final[DRD_LAYER_DS_INDEX_NB] = +{ + (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED), + (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED) +}; + + + +/*----------------------------------------------------------------------------*/ +/* Instrument_DS Indexes */ +/*----------------------------------------------------------------------------*/ + +#define DRD_INSTRUMENT_DS_INDEX_NB (short)2 + +static NDT_Index_Type DRG_Instrument_DS_Index_Tab_Initial[DRD_INSTRUMENT_DS_INDEX_NB] = +{ + (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED), + (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED) +}; + +static NDT_Index_Type DRG_Instrument_DS_Index_Tab_Final[DRD_INSTRUMENT_DS_INDEX_NB] = +{ + (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED), + (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED) +}; + + + +/*----------------------------------------------------------------------------*/ +/* Kit_DS Indexes */ +/*----------------------------------------------------------------------------*/ + +#define DRD_KIT_DS_INDEX_NB (short)2 + +static NDT_Index_Type DRG_Kit_DS_Index_Tab_Initial[DRD_KIT_DS_INDEX_NB] = +{ + (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED), + (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_SORTED) +}; + +static NDT_Index_Type DRG_Kit_DS_Index_Tab_Final[DRD_KIT_DS_INDEX_NB] = +{ + (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED), + (NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_TREE | NDD_INDEX_SUBTYPE_BALANCED) +}; + + + + + +/*---------------------------------------------------------------------------------*/ +/* XML XPATH Tags */ +/*---------------------------------------------------------------------------------*/ + +#define STR(A) #A +#define TAG(A) STR(A) + +#define XML_XPATH_ELEMENT(A) *[local-name()=(A)] +#define XML_SLASH / + +#define XML_XPATH_DRUMKIT_BASE_TAG XML_XPATH_ELEMENT('drumkit_info') +#define XML_XPATH_DRUMKIT_NAME_TAG XML_XPATH_ELEMENT('name') +#define XML_XPATH_DRUMKIT_INFO_TAG XML_XPATH_ELEMENT('info') +#define XML_XPATH_DRUMKIT_INSTRUMENTLIST_TAG XML_XPATH_ELEMENT('instrumentList') +#define XML_XPATH_DRUMKIT_INSTRUMENT_TAG XML_XPATH_ELEMENT('instrument') +#define XML_XPATH_DRUMKIT_ID_TAG XML_XPATH_ELEMENT('id') +#define XML_XPATH_DRUMKIT_GAIN_TAG XML_XPATH_ELEMENT('gain') +#define XML_XPATH_DRUMKIT_PAN_LEFT_TAG XML_XPATH_ELEMENT('pan_L') +#define XML_XPATH_DRUMKIT_PAN_RIGHT_TAG XML_XPATH_ELEMENT('pan_R') +#define XML_XPATH_DRUMKIT_INSTRUMENTCOMPONENT_TAG XML_XPATH_ELEMENT('instrumentComponent') +#define XML_XPATH_DRUMKIT_LAYER_TAG XML_XPATH_ELEMENT('layer') +#define XML_XPATH_DRUMKIT_FILENAME_TAG XML_XPATH_ELEMENT('filename') +#define XML_XPATH_DRUMKIT_MIN_TAG XML_XPATH_ELEMENT('min') +#define XML_XPATH_DRUMKIT_MAX_TAG XML_XPATH_ELEMENT('max') +#define XML_XPATH_DRUMKIT_PITCH_TAG XML_XPATH_ELEMENT('pitch') + +#define XML_XPATH_DRUMKIT_BASE_STR TAG(/XML_XPATH_DRUMKIT_BASE_TAG) +#define XML_XPATH_DRUMKIT_NAME_STR TAG(/XML_XPATH_DRUMKIT_NAME_TAG) +#define XML_XPATH_DRUMKIT_INFO_STR TAG(/XML_XPATH_DRUMKIT_INFO_TAG) +#define XML_XPATH_DRUMKIT_ID_STR TAG(/XML_XPATH_DRUMKIT_ID_TAG) +#define XML_XPATH_DRUMKIT_GAIN_STR TAG(/XML_XPATH_DRUMKIT_GAIN_TAG) +#define XML_XPATH_DRUMKIT_PAN_LEFT_STR TAG(/XML_XPATH_DRUMKIT_PAN_LEFT_TAG) +#define XML_XPATH_DRUMKIT_PAN_RIGHT_STR TAG(/XML_XPATH_DRUMKIT_PAN_RIGHT_TAG) +#define XML_XPATH_DRUMKIT_FILENAME_STR TAG(/XML_XPATH_DRUMKIT_FILENAME_TAG) +#define XML_XPATH_DRUMKIT_MIN_STR TAG(/XML_XPATH_DRUMKIT_MIN_TAG) +#define XML_XPATH_DRUMKIT_MAX_STR TAG(/XML_XPATH_DRUMKIT_MAX_TAG) +#define XML_XPATH_DRUMKIT_PITCH_STR TAG(/XML_XPATH_DRUMKIT_PITCH_TAG) + +#define XML_XPATH_DRUMKIT_KIT_NAME_FULL TAG(/XML_XPATH_DRUMKIT_BASE_TAG/XML_XPATH_DRUMKIT_NAME_TAG) +#define XML_XPATH_DRUMKIT_KIT_INFO_FULL TAG(/XML_XPATH_DRUMKIT_BASE_TAG/XML_XPATH_DRUMKIT_INFO_TAG) +#define XML_XPATH_DRUMKIT_INSTRUMENT_FULL TAG(/XML_XPATH_DRUMKIT_BASE_TAG/XML_XPATH_DRUMKIT_INSTRUMENTLIST_TAG/XML_XPATH_DRUMKIT_INSTRUMENT_TAG[%i]) +#define XML_XPATH_DRUMKIT_LAYER_FULL2 TAG(/XML_XPATH_DRUMKIT_BASE_TAG/XML_XPATH_DRUMKIT_INSTRUMENTLIST_TAG/XML_XPATH_DRUMKIT_INSTRUMENT_TAG[%i]/XML_XPATH_DRUMKIT_INSTRUMENTCOMPONENT_TAG/XML_XPATH_DRUMKIT_LAYER_TAG[%i]) +#define XML_XPATH_DRUMKIT_LAYER_FULL TAG(/XML_XPATH_DRUMKIT_BASE_TAG/XML_XPATH_DRUMKIT_INSTRUMENTLIST_TAG/XML_XPATH_DRUMKIT_INSTRUMENT_TAG[%i]XML_SLASH/XML_XPATH_DRUMKIT_LAYER_TAG[%i]) + + + + +/*---------------------------------------------------------------------------------*/ +/* LibSamplerate */ +/*---------------------------------------------------------------------------------*/ + +// Quality of conversion for libsamplerate. +// See http://www.mega-nerd.com/SRC/api_misc.html#Converters +// for info about availble qualities +#define RATE_CONV_QUALITY SRC_SINC_MEDIUM_QUALITY + + + + + +/*---------------------------------------------------------------------------------*/ +/* XML_Query */ +/*---------------------------------------------------------------------------------*/ + +#define XML_QUERY_VALUE_UNKNOWN (short) 0 +#define XML_QUERY_VALUE_STRING (short) 1 +#define XML_QUERY_VALUE_INT (short) 2 +#define XML_QUERY_VALUE_LONG (short) 3 +#define XML_QUERY_VALUE_LONGLONG (short) 4 +#define XML_QUERY_VALUE_FLOAT (short) 5 +#define XML_QUERY_VALUE_DOUBLE (short) 6 + +typedef struct DRT_XML_Query +{ + char *Query_Name; + char *XPath_Query; + short Value_Type; + long Value_Offset; + short Value_Len; +} DRT_XML_Query; + + + +DRT_XML_Query DRG_XML_Query_Tab_Layer[] = +{ + { "File Name", XML_XPATH_DRUMKIT_FILENAME_STR, XML_QUERY_VALUE_STRING, offsetof( DRT_Layer, FileName), FILENAME_LEN }, + { "Min", XML_XPATH_DRUMKIT_MIN_STR, XML_QUERY_VALUE_DOUBLE, offsetof( DRT_Layer, Min), 0 }, + { "Max", XML_XPATH_DRUMKIT_MAX_STR, XML_QUERY_VALUE_DOUBLE, offsetof( DRT_Layer, Max), 0 }, + { "Gain", XML_XPATH_DRUMKIT_GAIN_STR, XML_QUERY_VALUE_DOUBLE, offsetof( DRT_Layer, Gain), 0 }, + { "Pitch", XML_XPATH_DRUMKIT_PITCH_STR, XML_QUERY_VALUE_DOUBLE, offsetof( DRT_Layer, Pitch), 0 }, + { NULL, NULL, XML_QUERY_VALUE_UNKNOWN, 0, 0 } +}; + +DRT_XML_Query DRG_XML_Query_Tab_Instrument[] = +{ + { "Id", XML_XPATH_DRUMKIT_ID_STR, XML_QUERY_VALUE_LONG, offsetof( DRT_Instrument, Id), 0 }, + { "Name", XML_XPATH_DRUMKIT_NAME_STR, XML_QUERY_VALUE_STRING, offsetof( DRT_Instrument, Name), NAME_LEN }, + { "Gain", XML_XPATH_DRUMKIT_GAIN_STR, XML_QUERY_VALUE_DOUBLE, offsetof( DRT_Instrument, Gain), 0 }, + { "Pan_Left", XML_XPATH_DRUMKIT_PAN_LEFT_STR, XML_QUERY_VALUE_DOUBLE, offsetof( DRT_Instrument, Pan_Left), 0 }, + { "Pan_Right", XML_XPATH_DRUMKIT_PAN_RIGHT_STR, XML_QUERY_VALUE_DOUBLE, offsetof( DRT_Instrument, Pan_Right), 0 }, + { NULL, NULL, XML_QUERY_VALUE_UNKNOWN, 0, 0 } +}; + +DRT_XML_Query DRG_XML_Query_Tab_Kit[] = +{ + { "File", XML_XPATH_DRUMKIT_NAME_STR, XML_QUERY_VALUE_STRING, offsetof( DRT_Kit, Name), NAME_LEN }, + { "Desc", XML_XPATH_DRUMKIT_INFO_STR, XML_QUERY_VALUE_STRING, offsetof( DRT_Kit, Desc), DESC_LEN }, + { NULL, NULL, XML_QUERY_VALUE_UNKNOWN, 0, 0 } +}; + +# endif // ifdef _DATASTRUCT_C_ + + + + + +# ifndef _DATASTRUCT_C_ + +/*----------------------------------------------------------------------------*/ +/* Public Prototypes */ +/*----------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------------*/ +/* DR_Kit_Sample_Load */ +/*---------------------------------------------------------------------------------*/ + +extern DRT_Status DR_Kit_Sample_Load( DRT_Kit *, double); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_Kit_Load */ +/*---------------------------------------------------------------------------------*/ + +extern DRT_Status DR_Kit_Load( DRT_Base *, char *); + + + +/*----------------------------------------------------------------------------*/ +/* DR_Kits_Load */ +/*----------------------------------------------------------------------------*/ + +extern DRT_Status DR_Kits_Load( DRT_Base *); + + + +/*----------------------------------------------------------------------------*/ +/* DR_Kits_Dump */ +/*----------------------------------------------------------------------------*/ + +extern DRT_Status DR_Kits_Dump( DRT_Base *); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_DataStruct_Init */ +/*---------------------------------------------------------------------------------*/ + +extern DRT_Status DR_DataStruct_Init( DRT_Base *); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_DataStruct_DeInit */ +/*---------------------------------------------------------------------------------*/ + +extern DRT_Status DR_DataStruct_DeInit( DRT_Base *); + + + +# else // ifndef _DATA_STRUCT_C_ + + + +/*----------------------------------------------------------------------------*/ +/* Private Prototypes */ +/*----------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------------*/ +/* DS Managers */ +/*---------------------------------------------------------------------------------*/ + +NDT_Status DR_Layer_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list *); +NDT_Status DR_Instrument_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list *); +NDT_Status DR_Kit_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list *); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_Layer_Add */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_Layer_Add( DRT_Layer **, NDT_Root *, DRT_Layer *); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_Layer_Sample_Load */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_Layer_Sample_Load( DRT_Layer *, DRT_Kit *, double); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_Layer_Sample_UnLoad */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_Layer_Sample_UnLoad( DRT_Layer *); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_Layer_Dump */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_Layer_Dump( DRT_Layer *, long); + + + +/*----------------------------------------------------------------------------*/ +/* DR_Instrument_Add */ +/*----------------------------------------------------------------------------*/ + +DRT_Status DR_Instrument_Add( DRT_Instrument **, NDT_Root *, DRT_Instrument *); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_Instrument_Dump */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_Instrument_Dump( DRT_Instrument *, long); + + + +/*----------------------------------------------------------------------------*/ +/* DR_Kit_Add */ +/*----------------------------------------------------------------------------*/ + +DRT_Status DR_Kit_Add( DRT_Kit **, NDT_Root *, DRT_Kit *); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_Kit_Sample_Load */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_Kit_Sample_Load( DRT_Kit *, double); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_Kit_Dump */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_Kit_Dump( DRT_Kit *, long); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_XML_Node_Exist */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_XML_Node_Exist( xmlDocPtr, xmlXPathContextPtr, char *); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_XML_Query_Tab_Exec */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_XML_Query_Tab_Exec( void *, xmlDocPtr, xmlXPathContextPtr, char *, DRT_XML_Query *); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_XML_Value_Get */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_XML_Value_Get( char *, long, xmlDocPtr, xmlXPathContextPtr, char *, char *); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_Kit_Load */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_Kit_Load( DRT_Base *, char *); + + + +/*----------------------------------------------------------------------------*/ +/* DR_Kits_Load */ +/*----------------------------------------------------------------------------*/ + +DRT_Status DR_Kits_Load( DRT_Base *); + + + +/*----------------------------------------------------------------------------*/ +/* DR_Kits_Dump */ +/*----------------------------------------------------------------------------*/ + +DRT_Status DR_Kits_Dump( DRT_Base *); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_DataStruct_Init */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_DataStruct_Init( DRT_Base *); + + + +/*---------------------------------------------------------------------------------*/ +/* DR_DataStruct_DeInit */ +/*---------------------------------------------------------------------------------*/ + +DRT_Status DR_DataStruct_DeInit( DRT_Base *); + +# endif // ifndef _DATASTRUCT_C_ + + + + + +/*----------------------------------------------------------------------------*/ + +#endif // ifndef _DATASTRUCT_H_ + diff --git a/lv2_plugin.c b/lv2_plugin.c new file mode 100644 index 0000000..de945e2 --- /dev/null +++ b/lv2_plugin.c @@ -0,0 +1,24 @@ +/*---------------------------------------------------------------------------------*/ +/* Includes */ +/*---------------------------------------------------------------------------------*/ + +#define _LV2_PLUGIN_C_ + + + +#include + + + + + +/*---------------------------------------------------------------------------------*/ +/* */ +/*---------------------------------------------------------------------------------*/ + +static LV2_Handle instantiate(const LV2_Descriptor *descriptor, + double rate, + const char* bundle_path, + const LV2_Feature* const* features) +{ +} diff --git a/lv2_plugin.h b/lv2_plugin.h new file mode 100644 index 0000000..f9b103f --- /dev/null +++ b/lv2_plugin.h @@ -0,0 +1,325 @@ +/*---------------------------------------------------------------------------------*/ +/* Includes */ +/*---------------------------------------------------------------------------------*/ + +#ifndef _LV2_PLUGIN_H_ +#define _LV2_PLUGIN_H_ + +#include + +#include "lv2/lv2plug.in/ns/ext/atom/forge.h" +// util includes atom.h +#include "lv2/lv2plug.in/ns/ext/atom/util.h" +#include "lv2/lv2plug.in/ns/lv2core/lv2.h" +#include "lv2/lv2plug.in/ns/ext/urid/urid.h" +#include "lv2/lv2plug.in/ns/ext/state/state.h" + + + + + + + +/*----------------------------------------------------------------------------*/ +/* Global definitions */ +/*----------------------------------------------------------------------------*/ + +// lv2 stuff + +#define DRD_DRUMMER_URI "http://rx3.net/AlkorZ3/drummer" +#define DRD_GAIN_MIN -60.0f +#define DRD_GAIN_MAX 6.0f + + + +typedef enum +{ + DRD_LV2_CONTROL = 0, + DRD_LV2_MASTER_LEFT, + DRD_LV2_MASTER_RIGHT, + DRD_LV2_LEFT_00, + DRD_LV2_RIGHT_00, + DRD_LV2_LEFT_01, + DRD_LV2_RIGHT_01, + DRD_LV2_LEFT_02, + DRD_LV2_RIGHT_02, + DRD_LV2_LEFT_03, + DRD_LV2_RIGHT_03, + DRD_LV2_LEFT_04, + DRD_LV2_RIGHT_04, + DRD_LV2_LEFT_05, + DRD_LV2_RIGHT_05, + DRD_LV2_LEFT_06, + DRD_LV2_RIGHT_06, + DRD_LV2_LEFT_07, + DRD_LV2_RIGHT_07, + DRD_LV2_LEFT_08, + DRD_LV2_RIGHT_08, + DRD_LV2_LEFT_09, + DRD_LV2_RIGHT_09, + DRD_LV2_LEFT_10, + DRD_LV2_RIGHT_10, + DRD_LV2_LEFT_11, + DRD_LV2_RIGHT_11, + DRD_LV2_LEFT_12, + DRD_LV2_RIGHT_12, + DRD_LV2_LEFT_13, + DRD_LV2_RIGHT_13, + DRD_LV2_LEFT_14, + DRD_LV2_RIGHT_14, + DRD_LV2_LEFT_15, + DRD_LV2_RIGHT_15, + DRD_LV2_LEFT_16, + DRD_LV2_RIGHT_16, + DRD_LV2_LEFT_17, + DRD_LV2_RIGHT_17, + DRD_LV2_LEFT_18, + DRD_LV2_RIGHT_18, + DRD_LV2_LEFT_19, + DRD_LV2_RIGHT_19, + DRD_LV2_LEFT_20, + DRD_LV2_RIGHT_20, + DRD_LV2_LEFT_21, + DRD_LV2_RIGHT_21, + DRD_LV2_LEFT_22, + DRD_LV2_RIGHT_22, + DRD_LV2_LEFT_23, + DRD_LV2_RIGHT_23, + DRD_LV2_LEFT_24, + DRD_LV2_RIGHT_24, + DRD_LV2_LEFT_25, + DRD_LV2_RIGHT_25, + DRD_LV2_LEFT_26, + DRD_LV2_RIGHT_26, + DRD_LV2_LEFT_27, + DRD_LV2_RIGHT_27, + DRD_LV2_LEFT_28, + DRD_LV2_RIGHT_28, + DRD_LV2_LEFT_29, + DRD_LV2_RIGHT_29, + DRD_LV2_LEFT_30, + DRD_LV2_RIGHT_30, + DRD_LV2_LEFT_31, + DRD_LV2_RIGHT_31, + DRD_LV2_BASENOTE, + DRD_LV2_GAIN_ONE, + DRD_LV2_GAIN_TWO, + DRD_LV2_GAIN_THREE, + DRD_LV2_GAIN_FOUR, + DRD_LV2_GAIN_FIVE, + DRD_LV2_GAIN_SIX, + DRD_LV2_GAIN_SEVEN, + DRD_LV2_GAIN_EIGHT, + DRD_LV2_GAIN_NINE, + DRD_LV2_GAIN_TEN, + DRD_LV2_GAIN_ELEVEN, + DRD_LV2_GAIN_TWELVE, + DRD_LV2_GAIN_THIRTEEN, + DRD_LV2_GAIN_FOURTEEN, + DRD_LV2_GAIN_FIFTEEN, + DRD_LV2_GAIN_SIXTEEN, + DRD_LV2_GAIN_SEVENTEEN, + DRD_LV2_GAIN_EIGHTEEN, + DRD_LV2_GAIN_NINETEEN, + DRD_LV2_GAIN_TWENTY, + DRD_LV2_GAIN_TWENTYONE, + DRD_LV2_GAIN_TWENTYTWO, + DRD_LV2_GAIN_TWENTYTHREE, + DRD_LV2_GAIN_TWENTYFOUR, + DRD_LV2_GAIN_TWENTYFIVE, + DRD_LV2_GAIN_TWENTYSIX, + DRD_LV2_GAIN_TWENTYSEVEN, + DRD_LV2_GAIN_TWENTYEIGHT, + DRD_LV2_GAIN_TWENTYNINE, + DRD_LV2_GAIN_THIRTY, + DRD_LV2_GAIN_THIRTYONE, + DRD_LV2_GAIN_THIRTYTWO, + DRD_LV2_PAN_ONE, + DRD_LV2_PAN_TWO, + DRD_LV2_PAN_THREE, + DRD_LV2_PAN_FOUR, + DRD_LV2_PAN_FIVE, + DRD_LV2_PAN_SIX, + DRD_LV2_PAN_SEVEN, + DRD_LV2_PAN_EIGHT, + DRD_LV2_PAN_NINE, + DRD_LV2_PAN_TEN, + DRD_LV2_PAN_ELEVEN, + DRD_LV2_PAN_TWELVE, + DRD_LV2_PAN_THIRTEEN, + DRD_LV2_PAN_FOURTEEN, + DRD_LV2_PAN_FIFTEEN, + DRD_LV2_PAN_SIXTEEN, + DRD_LV2_PAN_SEVENTEEN, + DRD_LV2_PAN_EIGHTEEN, + DRD_LV2_PAN_NINETEEN, + DRD_LV2_PAN_TWENTY, + DRD_LV2_PAN_TWENTYONE, + DRD_LV2_PAN_TWENTYTWO, + DRD_LV2_PAN_TWENTYTHREE, + DRD_LV2_PAN_TWENTYFOUR, + DRD_LV2_PAN_TWENTYFIVE, + DRD_LV2_PAN_TWENTYSIX, + DRD_LV2_PAN_TWENTYSEVEN, + DRD_LV2_PAN_TWENTYEIGHT, + DRD_LV2_PAN_TWENTYNINE, + DRD_LV2_PAN_THIRTY, + DRD_LV2_PAN_THIRTYONE, + DRD_LV2_PAN_THIRTYTWO, + DRD_LV2_CORE_EVENT, + DRD_LV2_NUM_PORTS +} DRT_Port_Index; + + + +typedef struct +{ + LV2_URID midi_event; + LV2_URID ui_msg; + LV2_URID kit_path; + LV2_URID atom_eventTransfer; + LV2_URID atom_object; + LV2_URID string_urid; + LV2_URID bool_urid; + LV2_URID int_urid; + LV2_URID get_state; + LV2_URID midi_info; + LV2_URID sample_trigger; + LV2_URID velocity_toggle; + LV2_URID note_off_toggle; + LV2_URID channel_nb; + LV2_URID zero_position; + LV2_URID sample_add; + LV2_URID sample_remove; +} DRT_Drummer_URIS; + + + +typedef struct +{ + // Ports + float *Master_Left; + float *Master_Right; + float **Left; + float **Right; + LV2_Atom_Sequence *Control_Port; + LV2_Atom_Sequence *Core_Event_Port; + + LV2_Atom_Forge Forge; +} DRT_LV2_Base; + + + +typedef struct +{ + // Ports + float *master_left; + float *master_right; + float **left; + float **right; + LV2_Atom_Sequence *control_port; + LV2_Atom_Sequence *core_event_port; + + LV2_Atom_Forge forge; + + // params + int channel; + bool ignore_velocity; + bool ignore_note_off; + int channel_nb; + int zero_position; + float **gains; + float **pans; + float *baseNote; + double rate; + + // URIs + LV2_URID_Map *map; + drmr_uris uris; + + // Kit info + char *current_path; + char **request_buf; + int curReq; + + // Samples + drmr_sample *samples; + uint8_t num_samples; + + // loading thread stuff + pthread_mutex_t load_mutex; + pthread_cond_t load_cond; + pthread_t load_thread; +} DrMr; + + + +static inline void map_drmr_uris( LV2_URID_Map *map, drmr_uris *uris) +{ + uris->midi_event = map->map(map->handle, "http://lv2plug.in/ns/ext/midi#MidiEvent"); + uris->string_urid = map->map(map->handle, LV2_ATOM__String); + uris->bool_urid = map->map(map->handle, LV2_ATOM__Bool); + uris->int_urid = map->map(map->handle, LV2_ATOM__Int); + uris->ui_msg = map->map(map->handle, DRD_LV2_URI "#uimsg"); + uris->kit_path = map->map(map->handle, DRD_LV2_URI "#kitpath"); + uris->get_state = map->map(map->handle, DRD_LV2_URI "#getstate"); + uris->midi_info = map->map(map->handle, DRD_LV2_URI "#midiinfo"); + uris->sample_trigger = map->map(map->handle, DRD_LV2_URI "#sampletrigger"); + uris->velocity_toggle = map->map(map->handle, DRD_LV2_URI "#velocitytoggle"); + uris->note_off_toggle = map->map(map->handle, DRD_LV2_URI "#noteofftoggle"); + uris->channel_nb = map->map(map->handle, DRD_LV2_URI "#channelnb"); + uris->zero_position = map->map(map->handle, DRD_LV2_URI "#zeroposition"); + uris->sample_add = map->map(map->handle, DRD_LV2_URI "#sampleadd"); + uris->sample_remove = map->map(map->handle, DRD_LV2_URI "#sampleremove"); + uris->atom_eventTransfer = map->map(map->handle, LV2_ATOM__eventTransfer); + uris->atom_object = map->map(map->handle, LV2_ATOM__Object); +} + + + + + +# ifdef _LV2_PLUGIN_C_ + + + + + +/*----------------------------------------------------------------------------*/ +/* Private Definitions */ +/*----------------------------------------------------------------------------*/ + + + +# endif // ifdef _LV2_PLUGIN_C_ + + + + + +# ifndef _LV2_PLUGIN_C_ + +/*----------------------------------------------------------------------------*/ +/* Public Prototypes */ +/*----------------------------------------------------------------------------*/ + + + +# else // ifndef _LV2_PLUGIN_C_ + + + +/*----------------------------------------------------------------------------*/ +/* Private Prototypes */ +/*----------------------------------------------------------------------------*/ + +# endif // ifndef _LV2_PLUGIN_C_ + + + + + +/*----------------------------------------------------------------------------*/ + +#endif // ifndef _LV2_PLUGIN_H_ +