3128 lines
84 KiB
C
3128 lines
84 KiB
C
/*----------------------------------------------------------------------------*/
|
|
/* datastruct.c */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* This file is part of Drummer. */
|
|
/* */
|
|
/* Drummer is free software: you can redistribute it and/or modify it */
|
|
/* under the terms of the GNU General Public License as published by */
|
|
/* the Free Software Foundation, either version 3 of the License, or */
|
|
/* (at your option) any later version. */
|
|
/* */
|
|
/* Drummer is distributed in the hope that it will be useful, */
|
|
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
|
|
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
|
|
/* GNU General Public License for more details. */
|
|
/* */
|
|
/* You should have received a copy of the GNU General Public License */
|
|
/* along with Drummer. If not, see <https://www.gnu.org/licenses/>. */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* Includes */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
#define _DATASTRUCT_C_
|
|
|
|
|
|
|
|
#include <drummer.h>
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
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( ND_Alloc( (void **)Layer_Ptr_Ptr, Root_Ptr, sizeof( DRT_Layer), NULL) != NDS_OK)
|
|
{
|
|
return( NDS_KO);
|
|
}
|
|
else
|
|
{
|
|
( *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;
|
|
( *Layer_Ptr_Ptr)->Instrument_Ptr = Layer_Template_Ptr->Instrument_Ptr;
|
|
|
|
return( NDS_OK);
|
|
}
|
|
}
|
|
|
|
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);
|
|
|
|
if( ND_Free( (void *)Layer_Ptr, Root_Ptr, NULL) != NDS_OK)
|
|
{
|
|
return( NDS_KO);
|
|
}
|
|
else
|
|
{
|
|
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 *);
|
|
|
|
DRT_Layer *Layer_Ptr = Node_Ptr->Value;
|
|
DRT_Status status;
|
|
|
|
|
|
Command_Name = "NDD_CMD_SAMPLE_LOAD";
|
|
|
|
if( Layer_Ptr->Instrument_Ptr->Kit_Ptr->Base_Ptr->Task_Load_Layer_Flag == DRD_TRUE)
|
|
{
|
|
status = DR_Task_Run( DRD_TASK_CMD_LAYER_LOAD, (void *)Layer_Ptr);
|
|
}
|
|
else
|
|
{
|
|
status = DR_Layer_Sample_Load( Layer_Ptr);
|
|
}
|
|
|
|
if( status != 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( ND_Alloc( (void **)Instrument_Ptr_Ptr, Root_Ptr, sizeof( DRT_Instrument), NULL) != NDS_OK)
|
|
{
|
|
return( NDS_KO);
|
|
}
|
|
else
|
|
{
|
|
( *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;
|
|
( *Instrument_Ptr_Ptr)->Kit_Ptr = Instrument_Template_Ptr->Kit_Ptr;
|
|
|
|
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
if( ND_Free( (void *)Instrument_Ptr, Root_Ptr, NULL) != NDS_OK)
|
|
{
|
|
return( NDS_KO);
|
|
}
|
|
else
|
|
{
|
|
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 *);
|
|
|
|
DRT_Instrument *Instrument_Ptr = Node_Ptr->Value;
|
|
DRT_Status status;
|
|
|
|
|
|
Command_Name = "NDD_CMD_SAMPLE_LOAD";
|
|
|
|
if( Instrument_Ptr->Kit_Ptr->Base_Ptr->Task_Load_Instrument_Flag == DRD_TRUE)
|
|
{
|
|
status = DR_Task_Run( DRD_TASK_CMD_INSTRUMENT_LOAD, (void *)Instrument_Ptr);
|
|
}
|
|
else
|
|
{
|
|
status = DR_Instrument_Sample_Load( Instrument_Ptr);
|
|
}
|
|
|
|
if( status != 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_Instrument *Instrument_Ptr = Node_Ptr->Value;
|
|
|
|
|
|
Command_Name = "NDD_CMD_SAMPLE_UNLOAD";
|
|
|
|
if( DR_Instrument_Sample_UnLoad( Instrument_Ptr) != DRS_OK)
|
|
{
|
|
return( NDS_KO);
|
|
}
|
|
else
|
|
{
|
|
return( NDS_OK);
|
|
}
|
|
|
|
// 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->Id != DRD_ID_UNKNOWN)
|
|
{
|
|
*Reply_Index_Id_Ptr = 0;
|
|
}
|
|
else
|
|
{
|
|
// fprintf( stderr, "IDX 1!\n");
|
|
*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 = 0;
|
|
*Reply_Command_Ptr = Cmd;
|
|
break;
|
|
}
|
|
|
|
case NDD_CMD_ID_REFRESH:
|
|
{
|
|
*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( ND_Alloc( (void **)Kit_Ptr_Ptr, Root_Ptr, sizeof( DRT_Kit), NULL) != NDS_OK)
|
|
{
|
|
return( NDS_KO);
|
|
}
|
|
else
|
|
{
|
|
( *Kit_Ptr_Ptr)->Id = Root_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number;
|
|
( *Kit_Ptr_Ptr)->Logical_Id = Kit_Template_Ptr->Logical_Id;
|
|
( *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);
|
|
|
|
( *Kit_Ptr_Ptr)->Base_Ptr = Kit_Template_Ptr->Base_Ptr;
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
if( ND_Free( (void *)Kit_Ptr, Root_Ptr, NULL) != NDS_OK)
|
|
{
|
|
return( NDS_KO);
|
|
}
|
|
else
|
|
{
|
|
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:
|
|
{
|
|
if( ( Kit1_Ptr->Name[0] != 0) && ( Kit2_Ptr->Name[0] != 0))
|
|
{
|
|
rc = strcmp( Kit1_Ptr->Name, Kit2_Ptr->Name);
|
|
}
|
|
else
|
|
{
|
|
rc = Kit1_Ptr->Logical_Id - Kit2_Ptr->Logical_Id;
|
|
// fprintf( stderr, "Comp: (%ld) - (%ld) = (%ld)\n", Kit1_Ptr->Logical_Id, Kit2_Ptr->Logical_Id, rc);
|
|
}
|
|
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";
|
|
/*
|
|
fprintf( stderr, "CurId: (%03ld)", Kit_Ptr->Id);
|
|
fprintf( stderr, " ParentId: ");
|
|
|
|
if( Node_Ptr->Parent == NULL)
|
|
{
|
|
fprintf( stderr, "NULL ");
|
|
}
|
|
else
|
|
{
|
|
fprintf( stderr, "(%03ld)", ((DRT_Kit *)Node_Ptr->Parent->Value)->Id);
|
|
}
|
|
|
|
fprintf( stderr, " LeftId: ");
|
|
|
|
if( Node_Ptr->Left == NULL)
|
|
{
|
|
fprintf( stderr, "NULL ");
|
|
}
|
|
else
|
|
{
|
|
fprintf( stderr, "(%03ld)", ((DRT_Kit *)Node_Ptr->Left->Value)->Id);
|
|
}
|
|
|
|
fprintf( stderr, " RightId: ");
|
|
|
|
if( Node_Ptr->Right == NULL)
|
|
{
|
|
fprintf( stderr, "NULL ");
|
|
}
|
|
else
|
|
{
|
|
fprintf( stderr, "(%03ld)", ((DRT_Kit *)Node_Ptr->Right->Value)->Id);
|
|
}
|
|
|
|
fprintf( stderr, "\n");
|
|
|
|
return( NDS_OK);
|
|
*/
|
|
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_GRAPH_PRINT:
|
|
{
|
|
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
|
|
|
|
DRT_Kit *Kit_Ptr = Node_Ptr->Value;
|
|
|
|
|
|
Command_Name = "NDD_CMD_GRAPH_PRINT";
|
|
|
|
fprintf( stderr, " node%03ld [ label =\"<f0> | <f1> %03ld\\n%20s | <f2> \"];\n", Kit_Ptr->Id, Kit_Ptr->Id, Kit_Ptr->Name);
|
|
|
|
if( Node_Ptr->Left != NULL)
|
|
{
|
|
fprintf( stderr, " node%03ld:f0 -> node%03ld:f1;\n", Kit_Ptr->Id, ((DRT_Kit *)Node_Ptr->Left->Value)->Id);
|
|
}
|
|
|
|
if( Node_Ptr->Right != NULL)
|
|
{
|
|
fprintf( stderr, " node%03ld:f2 -> node%03ld:f1;\n", Kit_Ptr->Id, ((DRT_Kit *)Node_Ptr->Right->Value)->Id);
|
|
}
|
|
|
|
fprintf( stderr, "\n");
|
|
|
|
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_ID_REFRESH:
|
|
{
|
|
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
|
|
|
|
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
|
|
|
|
ND_VA_ARG_GET( Count_Ptr, user_args, DRT_Kit_Id *);
|
|
|
|
ND_VA_LIST_CLOSE( user_args);
|
|
|
|
DRT_Kit *Kit_Ptr = Node_Ptr->Value;
|
|
|
|
|
|
Command_Name = "NDD_CMD_ID_REFRESH";
|
|
|
|
Kit_Ptr->Logical_Id = (*Count_Ptr)++;
|
|
|
|
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 *);
|
|
|
|
DRT_Kit *Kit_Ptr = Node_Ptr->Value;
|
|
DRT_Status status;
|
|
|
|
|
|
Command_Name = "NDD_CMD_SAMPLE_LOAD";
|
|
|
|
if( Kit_Ptr->Base_Ptr->Task_Load_Kit_Flag == DRD_TRUE)
|
|
{
|
|
status = DR_Task_Run( DRD_TASK_CMD_KIT_LOAD, (void *)Kit_Ptr);
|
|
}
|
|
else
|
|
{
|
|
status = DR_Kit_Sample_Load( Kit_Ptr);
|
|
}
|
|
|
|
if( status != 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( (void **)Layer_Ptr_Ptr, DS_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_Status status;
|
|
SNDFILE *sndf_ptr;
|
|
DRT_SampleRate samplerate = DRG_Base.SampleRate;
|
|
|
|
|
|
// 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);
|
|
|
|
if( ND_Free( (void *)Layer_Ptr->SF_Info_Ptr, Layer_Ptr->Instrument_Ptr->Layer_DS_Ptr, NULL) != NDS_OK)
|
|
{
|
|
return( DRS_KO);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( Layer_Ptr->Sample_Ptr != NULL)
|
|
{
|
|
fprintf( stderr, "Freeing Sample: [%s]\n", Layer_Ptr->FileName);
|
|
|
|
if( ND_Free( (void *)Layer_Ptr->Sample_Ptr, Layer_Ptr->Instrument_Ptr->Layer_DS_Ptr, NULL) != NDS_OK)
|
|
{
|
|
return( DRS_KO);
|
|
}
|
|
}
|
|
}
|
|
|
|
if( ND_Alloc( (void **)&( Layer_Ptr->SF_Info_Ptr), Layer_Ptr->Instrument_Ptr->Layer_DS_Ptr, sizeof( SF_INFO), NULL) != NDS_OK)
|
|
{
|
|
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)
|
|
{
|
|
LG_LOG_WARNING_2( "Can't open sample file [%s] (%ld)!", 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( ND_Alloc( (void **)&( Layer_Ptr->Sample_Ptr), Layer_Ptr->Instrument_Ptr->Layer_DS_Ptr, ( Layer_Ptr->Sample_Size * sizeof( float)), NULL) != NDS_OK)
|
|
{
|
|
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( ND_Alloc( (void **)&( src_data.data_out), Layer_Ptr->Instrument_Ptr->Layer_DS_Ptr, out_size, NULL) != NDS_OK)
|
|
{
|
|
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));
|
|
|
|
ND_Free( (void *)src_data.data_out, Layer_Ptr->Instrument_Ptr->Layer_DS_Ptr, NULL);
|
|
|
|
status = DRS_KO;
|
|
}
|
|
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);
|
|
}
|
|
|
|
ND_Free( (void *)Layer_Ptr->Sample_Ptr, Layer_Ptr->Instrument_Ptr->Layer_DS_Ptr, NULL);
|
|
|
|
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");
|
|
|
|
if( ND_Free( (void *)Layer_Ptr->Sample_Ptr, Layer_Ptr->Instrument_Ptr->Layer_DS_Ptr, NULL) != NDS_OK)
|
|
{
|
|
return( DRS_KO);
|
|
}
|
|
}
|
|
|
|
if( Layer_Ptr->SF_Info_Ptr != NULL)
|
|
{
|
|
// fprintf( stderr, "Freeing SF_Info!\n");
|
|
if( ND_Free( (void *)Layer_Ptr->SF_Info_Ptr, Layer_Ptr->Instrument_Ptr->Layer_DS_Ptr, NULL) != NDS_OK)
|
|
{
|
|
return( DRS_KO);
|
|
}
|
|
}
|
|
|
|
return( DRS_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: (% 3ld) File Name: [%s] Sample: [%lx] Sample Size: (%ld) Min: (%f) Max: (%f) Gain: (%f) Pitch: (%f) Intrument Id: (% 3ld)",
|
|
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, Layer_Ptr->Instrument_Ptr->Id);
|
|
|
|
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( (void **)Instrument_Ptr_Ptr, DS_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: (% 3ld) Name: [%s] Gain: (%f) Pan Left: (%f) Pan Right: (%f) Kit Id: (% 3ld)\n",
|
|
Instrument_Ptr->Id, Instrument_Ptr->Name, Instrument_Ptr->Gain, Instrument_Ptr->Pan_Left, Instrument_Ptr->Pan_Right, Instrument_Ptr->Kit_Ptr->Id);
|
|
// 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_Instrument_Sample_Load */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_Instrument_Sample_Load( DRT_Instrument *Instrument_Ptr)
|
|
{
|
|
NDT_Status nd_status;
|
|
|
|
|
|
if( ( nd_status = ND_DataStruct_Traverse( Instrument_Ptr->Layer_DS_Ptr, NDD_CMD_SAMPLE_LOAD)) != NDS_OK)
|
|
{
|
|
printf( "Cant't load instrument samples: ND_DataStruct_Traverse() failed (%d)!\n", nd_status);
|
|
return( DRS_KO);
|
|
}
|
|
|
|
return( DRS_OK);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_Instrument_Sample_UnLoad */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_Instrument_Sample_UnLoad( DRT_Instrument *Instrument_Ptr)
|
|
{
|
|
NDT_Status nd_status;
|
|
|
|
|
|
if( ( nd_status = ND_DataStruct_Traverse( Instrument_Ptr->Layer_DS_Ptr, NDD_CMD_SAMPLE_UNLOAD)) != NDS_OK)
|
|
{
|
|
printf( "Cant't unload instrument samples: ND_DataStruct_Traverse() failed (%d)\n", nd_status);
|
|
return( DRS_KO);
|
|
}
|
|
|
|
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( (void **)Kit_Ptr_Ptr, DS_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, DRT_Kit_Id Kit_Id)
|
|
{
|
|
DRT_Status status;
|
|
NDT_Status nd_status;
|
|
DRT_Kit kit_template;
|
|
|
|
|
|
kit_template.Id = Kit_Id;
|
|
kit_template.Logical_Id = DRD_ID_UNKNOWN;
|
|
kit_template.Name[0] = '\0';
|
|
|
|
if( ( nd_status = ND_DataStruct_Value_Find( (void **)Kit_Ptr_Ptr, DRG_Base.Kit_DS_Ptr, &kit_template)) != NDS_OK)
|
|
{
|
|
LG_LOG_ERROR_1( "DR_Kit_Id_Find: Find error: (%d)!", nd_status);
|
|
status = DRS_KO;
|
|
}
|
|
else
|
|
{
|
|
if( *Kit_Ptr_Ptr == NULL)
|
|
{
|
|
LG_LOG_WARNING_1( "Can't find: Kit with id: (%ld)!", Kit_Id);
|
|
status = DRS_KO;
|
|
}
|
|
else
|
|
{
|
|
status = DRS_OK;
|
|
}
|
|
}
|
|
|
|
return( status);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_Kit_Logical_Id_Find */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_Kit_Logical_Id_Find( DRT_Kit **Kit_Ptr_Ptr, DRT_Kit_Id Kit_Logical_Id)
|
|
{
|
|
DRT_Status status;
|
|
NDT_Status nd_status;
|
|
DRT_Kit kit_template;
|
|
|
|
|
|
kit_template.Id = DRD_ID_UNKNOWN;
|
|
kit_template.Logical_Id = Kit_Logical_Id;
|
|
kit_template.Name[0] = '\0';
|
|
|
|
if( ( nd_status = ND_DataStruct_Value_Find( (void **)Kit_Ptr_Ptr, DRG_Base.Kit_DS_Ptr, &kit_template)) != NDS_OK)
|
|
{
|
|
LG_LOG_ERROR_1( "DR_Kit_Logical_Id_Find: Find error: (%d)!", nd_status);
|
|
status = DRS_KO;
|
|
}
|
|
else
|
|
{
|
|
if( *Kit_Ptr_Ptr == NULL)
|
|
{
|
|
LG_LOG_WARNING_1( "DR_Kit_Logical_Id_Find: Can't find: kit with logical id: [%d]!", Kit_Logical_Id);
|
|
status = DRS_KO;
|
|
}
|
|
else
|
|
{
|
|
status = DRS_OK;
|
|
}
|
|
}
|
|
|
|
return( status);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_Kit_Name_Find */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_Kit_Name_Find( DRT_Kit **Kit_Ptr_Ptr, char *Kit_Name)
|
|
{
|
|
DRT_Status status;
|
|
NDT_Status nd_status;
|
|
DRT_Kit kit_template;
|
|
|
|
|
|
kit_template.Id = DRD_ID_UNKNOWN;
|
|
kit_template.Logical_Id = DRD_ID_UNKNOWN;
|
|
strncpy( kit_template.Name, Kit_Name, DRD_NAME_LEN);
|
|
|
|
if( ( nd_status = ND_DataStruct_Value_Find( (void **)Kit_Ptr_Ptr, DRG_Base.Kit_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: (% 3ld) Logical Id: (% 3ld) Status: [%s] Name: [%s] Descrition: [%.32s] Dir Name: [%s] Sample Rate: (%d)\n",
|
|
Kit_Ptr->Id, Kit_Ptr->Logical_Id, DR_LOAD_STATUS_ASCII_GET( Kit_Ptr), Kit_Ptr->Name, Kit_Ptr->Desc, Kit_Ptr->DirName, Kit_Ptr->Base_Ptr->SampleRate);
|
|
fprintf( stderr, " Instruments List:\n");
|
|
|
|
if( Kit_Ptr->Instrument_DS_Ptr == NULL)
|
|
{
|
|
fprintf( stderr, " Uninitialised list!\n");
|
|
}
|
|
else
|
|
{
|
|
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))
|
|
{
|
|
LG_LOG_WARNING_1( "[%s] not found!", xpath_request);
|
|
status = DRS_KO;
|
|
}
|
|
else
|
|
{
|
|
if( ( tmpval_ptr = (char *)xmlNodeListGetString( Xml_Doc, nodeset->nodeTab[0]->xmlChildrenNode, 1)) == NULL)
|
|
{
|
|
LG_LOG_WARNING_1( "[%s] value not found!", 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( 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.Id = DRD_ID_UNKNOWN;
|
|
kit_template.Logical_Id = DRD_ID_UNKNOWN;
|
|
kit_template.Status = DRD_LOAD_STATUS_UNLOADED;
|
|
kit_template.Base_Ptr = &DRG_Base;
|
|
layer_template.Sample_Ptr = NULL;
|
|
layer_template.Sample_Size = 0;
|
|
layer_template.SF_Info_Ptr = NULL;
|
|
|
|
|
|
// fprintf( stderr, "Loading: [%s]...\n", FileName);
|
|
LG_LOG_INFO_1( "Loading: [%s]...", 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, DRG_Base.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;
|
|
instrument_template.Kit_Ptr = kit_ptr;
|
|
|
|
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;
|
|
layer_template.Instrument_Ptr = instrument_ptr;
|
|
|
|
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)
|
|
{
|
|
NDT_Status nd_status;
|
|
|
|
|
|
if( DR_LOAD_STATUS_LOADED_IS( Kit_Ptr))
|
|
{
|
|
LG_LOG_INFO_1( "Loading kit samples: [%s] Skiped!", Kit_Ptr->Name);
|
|
}
|
|
else
|
|
{
|
|
LG_LOG_INFO_1( "Loading kit samples: [%s]!", Kit_Ptr->Name);
|
|
|
|
if( ( nd_status = ND_DataStruct_Traverse( Kit_Ptr->Instrument_DS_Ptr, NDD_CMD_SAMPLE_LOAD)) != NDS_OK)
|
|
{
|
|
printf( "Cant't load kit samples: ND_DataStruct_Traverse() failed (%d)!\n", nd_status);
|
|
return( DRS_KO);
|
|
}
|
|
|
|
if( DRG_Base.Task_Sync_Kit_Flag == DRD_TRUE)
|
|
{
|
|
if( DR_Task_Wait() != DRS_OK)
|
|
{
|
|
printf( "DR_Task_Wait failed (%d)!\n");
|
|
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))
|
|
{
|
|
LG_LOG_INFO_1( "UnLoading kit samples: [%s] Skiped!", Kit_Ptr->Name);
|
|
}
|
|
else
|
|
{
|
|
LG_LOG_INFO_1( "UnLoading kit samples: [%s]!", 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_Kits_Sample_Load */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_Kits_Sample_Load()
|
|
{
|
|
NDT_Status nd_status;
|
|
|
|
|
|
LG_LOG_INFO_0( "Loading kits samples!");
|
|
|
|
if( ( nd_status = ND_DataStruct_Traverse( DRG_Base.Kit_DS_Ptr, NDD_CMD_SAMPLE_LOAD)) != NDS_OK)
|
|
{
|
|
printf( "Cant't load kit samples: ND_DataStruct_Traverse() failed (%d)!\n", nd_status);
|
|
return( DRS_KO);
|
|
}
|
|
|
|
if( DRG_Base.Task_Sync_Kits_Flag == DRD_TRUE)
|
|
{
|
|
LG_LOG_INFO_0( "Synchronising...");
|
|
|
|
if( DR_Task_Wait() != DRS_OK)
|
|
{
|
|
fprintf( stderr, "DR_Task_Wait failed (%d)!\n");
|
|
return( DRS_KO);
|
|
}
|
|
|
|
LG_LOG_INFO_0( "Sync done!");
|
|
}
|
|
|
|
return( DRS_OK);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_Kits_Sample_UnLoad */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_Kits_Sample_UnLoad()
|
|
{
|
|
NDT_Status nd_status;
|
|
|
|
|
|
LG_LOG_INFO_0( "UnLoading kits samples!");
|
|
|
|
if( ( nd_status = ND_DataStruct_Traverse( DRG_Base.Kit_DS_Ptr, NDD_CMD_SAMPLE_UNLOAD, DRG_Base.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_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;
|
|
DRT_Kit_Id count = 0L;
|
|
|
|
|
|
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( 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_Traverse( DRG_Base.Kit_DS_Ptr, NDD_CMD_ID_REFRESH, &count)) != NDS_OK)
|
|
{
|
|
printf( "Can't refresh kit id: ND_DataStruct_Traverse() failed (%d)!\n", nd_status);
|
|
status = DRS_KO;
|
|
}
|
|
else
|
|
{
|
|
if( ( nd_status = ND_DataStruct_Convert( DRG_Base.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);
|
|
|
|
// DR_Kits_Dump();
|
|
|
|
// DRG_Base.SampleRate=44100;
|
|
|
|
/*
|
|
status = DR_Layer_Sample_Load( (DRT_Layer *)(
|
|
((DRT_Instrument *)(
|
|
((DRT_Kit *)(DRG_Base.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 *)( DRG_Base.Kit_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Head->Value), DRG_Base.SampleRate);
|
|
*/
|
|
|
|
/*
|
|
if( DRG_Base.Kit_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Head != NULL)
|
|
{
|
|
status = DR_Kit_Sample_Load( (DRT_Kit *)(DRG_Base.Kit_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Head->Value),
|
|
DRG_Base.SampleRate);
|
|
}
|
|
*/
|
|
|
|
// status = DR_Kits_Sample_Load();
|
|
|
|
return( status);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_Kits_Name_Get */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_Kits_Name_Get( DRT_Kit_Name **Kit_Name_Tab_Ptr, long *Kit_Number_Ptr)
|
|
{
|
|
NDT_Status nd_status;
|
|
NDT_Node *node_cur_ptr;
|
|
DRT_Kit *kit_cur_ptr;
|
|
long kit_id;
|
|
|
|
|
|
*Kit_Number_Ptr = DRG_Base.Kit_DS_Ptr->Index_Tab[NDD_INDEX_PRIMARY].Node_Number;
|
|
|
|
if( *Kit_Number_Ptr == 0)
|
|
{
|
|
*Kit_Name_Tab_Ptr = NULL;
|
|
|
|
return( DRS_OK);
|
|
}
|
|
else
|
|
{
|
|
if( ( nd_status = ND_Index_Node_First_Get( &node_cur_ptr, DRG_Base.Kit_DS_Ptr, 1)) != NDS_OK)
|
|
{
|
|
LG_LOG_INFO_1( "Can't find the first kit: ND_Index_Node_First_Get() failed (%d)!", nd_status);
|
|
*Kit_Name_Tab_Ptr = NULL;
|
|
|
|
return( DRS_KO);
|
|
}
|
|
else
|
|
{
|
|
if( ( *Kit_Name_Tab_Ptr = malloc( sizeof( DRT_Kit_Name) * *Kit_Number_Ptr)) == NULL)
|
|
{
|
|
LG_LOG_INFO_0( "Can't allocate kit name tab memory!");
|
|
*Kit_Name_Tab_Ptr = NULL;
|
|
|
|
return( DRS_KO);
|
|
}
|
|
else
|
|
{
|
|
kit_id = 0;
|
|
|
|
while( node_cur_ptr != NULL)
|
|
{
|
|
kit_cur_ptr = node_cur_ptr->Value;
|
|
// LG_LOG_INFO_1( "Kit Name: [%s]", kit_cur_ptr->Name);
|
|
|
|
(*Kit_Name_Tab_Ptr)[ kit_id].Id = kit_cur_ptr->Id;
|
|
(*Kit_Name_Tab_Ptr)[ kit_id].Logical_Id = kit_cur_ptr->Logical_Id;
|
|
strcpy( (*Kit_Name_Tab_Ptr)[ kit_id].Name, kit_cur_ptr->Name);
|
|
|
|
kit_id++;
|
|
|
|
if( ( nd_status = ND_Index_Node_Next_Get( &node_cur_ptr, node_cur_ptr)) != NDS_OK)
|
|
{
|
|
LG_LOG_INFO_1( "Can't find the next kit: ND_Index_Node_Next_Get() failed (%d)!", nd_status);
|
|
node_cur_ptr = NULL;
|
|
}
|
|
}
|
|
|
|
return( DRS_OK);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_Kits_Stats_Dump */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_Kits_Stats_Dump()
|
|
{
|
|
NDT_Status nd_status;
|
|
DRT_Id kit_count = 0;
|
|
DRT_Id instrument_count = 0;
|
|
DRT_Id layer_count = 0;
|
|
DRT_Id sample_count = 0;
|
|
|
|
|
|
if( ( nd_status = ND_DataStruct_Traverse( DRG_Base.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);
|
|
}
|
|
|
|
LG_LOG_INFO_4( "Number of Kits: (%ld) Number of Instruments: (%ld) Number of Layers: (%ld) Number of Loaded Samples: (%ld)", kit_count, instrument_count, layer_count, sample_count);
|
|
|
|
return( DRS_OK);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_Kits_Dump */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_Kits_Dump()
|
|
{
|
|
NDT_Status nd_status;
|
|
DRT_Kit_Id count = 0;
|
|
|
|
|
|
fprintf( stderr, "\n");
|
|
fprintf( stderr, "Sample Rate: (%d)\n", DRG_Base.SampleRate);
|
|
fprintf( stderr, "DrumKit List:\n");
|
|
|
|
if( ( nd_status = ND_DataStruct_Value_Print( stderr, DRG_Base.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( DR_Kits_Stats_Dump() != DRS_OK)
|
|
{
|
|
return( DRS_KO);
|
|
}
|
|
|
|
return( DRS_OK);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_Kits_Graph_Dump */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_Kits_Graph_Dump()
|
|
{
|
|
NDT_Status nd_status;
|
|
|
|
|
|
fprintf( stderr, "digraph G\n{\n node [shape = record];\n\n");
|
|
|
|
if( ( nd_status = ND_DataStruct_Traverse( DRG_Base.Kit_DS_Ptr, NDD_CMD_GRAPH_PRINT)) != NDS_OK)
|
|
{
|
|
printf( "Can't dump graph kits: ND_DataStruct_Value_Print() failed (%d)!\n", nd_status);
|
|
return( DRS_KO);
|
|
}
|
|
|
|
fprintf( stderr, "}\n");
|
|
|
|
return( DRS_OK);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_Task_Tread */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
static void *DR_Task_Thread()
|
|
{
|
|
pthread_t my_thread_id = pthread_self();
|
|
short task_id;
|
|
|
|
|
|
// fprintf( stderr, "Start Task Thread (%d)!\n", my_thread_id);
|
|
|
|
for( task_id = 0; ( DRG_Base.Task_Tab[task_id].Thread != my_thread_id) && ( task_id < DRG_Base.Task_Number); task_id++);
|
|
|
|
if( task_id == DRG_Base.Task_Number)
|
|
{
|
|
fprintf( stderr, "Can't find my id: (%d)!\n", my_thread_id);
|
|
}
|
|
else
|
|
{
|
|
// fprintf( stderr, "I'm: (%02d)!\n", task_id);
|
|
|
|
pthread_mutex_lock( &( DRG_Base.Task_Mutex));
|
|
|
|
do
|
|
{
|
|
switch( DRG_Base.Task_Tab[task_id].Command)
|
|
{
|
|
case DRD_TASK_CMD_TASK_SPAWN:
|
|
{
|
|
// fprintf( stderr, "I'm: (%02d) Spawning!\n", task_id);
|
|
|
|
DRG_Base.Task_Tab[task_id].Status = DRD_TASK_STATUS_RUNNING;
|
|
DRG_Base.Task_Tab[task_id].Count = 0L;
|
|
break;
|
|
}
|
|
|
|
case DRD_TASK_CMD_TASK_KILL:
|
|
{
|
|
// fprintf( stderr, "I'm: (%02d) Killing!\n", task_id);
|
|
|
|
DRG_Base.Task_Tab[task_id].Status = DRD_TASK_STATUS_KILLED;
|
|
|
|
pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
break;
|
|
}
|
|
|
|
case DRD_TASK_CMD_INSTRUMENT_LOAD:
|
|
case DRD_TASK_CMD_LAYER_LOAD:
|
|
case DRD_TASK_CMD_KIT_LOAD:
|
|
{
|
|
DRG_Base.Task_Tab[task_id].Status = DRD_TASK_STATUS_RUNNING;
|
|
// DRG_Base.Task_Count_Waiting--;
|
|
|
|
pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
|
|
switch( DRG_Base.Task_Tab[task_id].Command)
|
|
{
|
|
case DRD_TASK_CMD_LAYER_LOAD:
|
|
{
|
|
DR_Layer_Sample_Load( (DRT_Layer *)( DRG_Base.Task_Tab[task_id].Target_Ptr));
|
|
break;
|
|
}
|
|
|
|
case DRD_TASK_CMD_INSTRUMENT_LOAD:
|
|
{
|
|
DR_Instrument_Sample_Load( (DRT_Instrument *)( DRG_Base.Task_Tab[task_id].Target_Ptr));
|
|
break;
|
|
}
|
|
|
|
case DRD_TASK_CMD_KIT_LOAD:
|
|
{
|
|
DR_Kit_Sample_Load( (DRT_Kit *)( DRG_Base.Task_Tab[task_id].Target_Ptr));
|
|
break;
|
|
}
|
|
}
|
|
|
|
DRG_Base.Task_Tab[task_id].Count++;
|
|
|
|
pthread_mutex_lock( &( DRG_Base.Task_Mutex));
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
printf( "DR_Task_Thread called with an undefined command [%d] [%s]\n", DRG_Base.Task_Tab[task_id].Command, DR_TASK_CMD_ASCII_GET( &(DRG_Base.Task_Tab[task_id])));
|
|
|
|
}
|
|
}
|
|
|
|
if( DR_TASK_STATUS_RUNNING_IS( &( DRG_Base.Task_Tab[task_id])))
|
|
{
|
|
// fprintf( stderr, "I'm: (%02d) Waiting!\n", task_id);
|
|
|
|
DRG_Base.Task_Tab[task_id].Status = DRD_TASK_STATUS_WAITING;
|
|
DRG_Base.Task_Tab[task_id].Command = DRD_TASK_CMD_NONE;
|
|
DRG_Base.Task_Tab[task_id].Target_Ptr = NULL;
|
|
DRG_Base.Task_Count_Waiting++;
|
|
|
|
pthread_cond_signal( &( DRG_Base.Task_Cond));
|
|
pthread_cond_wait( &( DRG_Base.Task_Tab[task_id].Cond), &( DRG_Base.Task_Mutex));
|
|
}
|
|
}
|
|
while( ! DR_TASK_STATUS_KILLED_IS( &( DRG_Base.Task_Tab[task_id])));
|
|
|
|
pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
|
|
// fprintf( stderr, "I'm: (%02d) and killed!\n", task_id);
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_Task_Id_Run */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_Task_Id_Run( DRT_Task_Id Task_Id, DRT_Task_Command Command, void *Target_Ptr)
|
|
{
|
|
DRT_Status status;
|
|
|
|
|
|
// pthread_mutex_lock( &( DRG_Base.Task_Mutex));
|
|
|
|
if( !DR_TASK_STATUS_WAITING_IS( &( DRG_Base.Task_Tab[Task_Id])))
|
|
{
|
|
fprintf( stderr, "Task_Id_Run: Inconsistent task status: [%s]!\n", DR_TASK_STATUS_ASCII_GET( &( DRG_Base.Task_Tab[Task_Id])));
|
|
// pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
|
|
status = DRS_KO;
|
|
}
|
|
else
|
|
{
|
|
DRG_Base.Task_Tab[Task_Id].Command = Command;
|
|
DRG_Base.Task_Tab[Task_Id].Target_Ptr = Target_Ptr;
|
|
DRG_Base.Task_Count_Waiting--;
|
|
|
|
pthread_cond_signal( &( DRG_Base.Task_Tab[Task_Id].Cond));
|
|
// pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
|
|
|
|
status = DRS_OK;
|
|
}
|
|
|
|
return( status);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_Task_Kill */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_Task_Id_Kill( DRT_Task_Id Task_Id)
|
|
{
|
|
DRT_Status status;
|
|
|
|
|
|
pthread_mutex_lock( &( DRG_Base.Task_Mutex));
|
|
|
|
if( !DR_TASK_STATUS_WAITING_IS( &( DRG_Base.Task_Tab[Task_Id])))
|
|
{
|
|
fprintf( stderr, "Task_Kill: Inconsistent task status: [%s]!\n", DR_TASK_STATUS_ASCII_GET( &( DRG_Base.Task_Tab[Task_Id])));
|
|
pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
|
|
status = DRS_KO;
|
|
}
|
|
else
|
|
{
|
|
// fprintf( stderr, "Killing task id: (%d)!\n", Task_Id);
|
|
|
|
DRG_Base.Task_Tab[Task_Id].Command = DRD_TASK_CMD_TASK_KILL;
|
|
DRG_Base.Task_Tab[Task_Id].Target_Ptr = NULL;
|
|
|
|
pthread_cond_signal( &( DRG_Base.Task_Tab[Task_Id].Cond));
|
|
pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
|
|
status = DRS_OK;
|
|
}
|
|
|
|
return( status);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_Task_Run */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_Task_Run( DRT_Task_Command Command, void *Target_Ptr)
|
|
{
|
|
DRT_Task_Id task_id;
|
|
DRT_Boolean found = DRD_FALSE;
|
|
|
|
|
|
// fprintf( stderr, "Task Run: Called!\n");
|
|
|
|
DRG_Base.Task_Count_Run++;
|
|
|
|
while( found != DRD_TRUE)
|
|
{
|
|
pthread_mutex_lock( &( DRG_Base.Task_Mutex));
|
|
|
|
if( DRG_Base.Task_Count_Waiting > 0)
|
|
{
|
|
// while( ( task_id < DRG_Base.Task_Number) && ( found != DRD_TRUE))
|
|
for( task_id = 0; ( task_id < DRG_Base.Task_Number) && ( found != DRD_TRUE); task_id++)
|
|
{
|
|
if( DR_TASK_STATUS_WAITING_IS( &( DRG_Base.Task_Tab[task_id])) && DR_TASK_CMD_NONE_IS( &( DRG_Base.Task_Tab[task_id])))
|
|
{
|
|
// pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
// fprintf( stderr, "Task Run: Found (%d)!\n", task_id);
|
|
|
|
if( DR_Task_Id_Run( task_id, Command, Target_Ptr) != DRS_OK)
|
|
{
|
|
fprintf( stderr, "Can't run task !\n");
|
|
|
|
pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
return( DRS_KO);
|
|
}
|
|
|
|
pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
found = DRD_TRUE;
|
|
}
|
|
}
|
|
|
|
if( found != DRD_TRUE)
|
|
{
|
|
DR_Tasks_Dump();
|
|
DRG_Base.Task_Count_FakeWU++;
|
|
}
|
|
}
|
|
|
|
if( found != DRD_TRUE)
|
|
{
|
|
// fprintf( stderr, "Task Run: Sleeping!\n");
|
|
|
|
DRG_Base.Task_Count_Sleep++;
|
|
|
|
pthread_cond_wait( &( DRG_Base.Task_Cond), &( DRG_Base.Task_Mutex));
|
|
pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
}
|
|
}
|
|
|
|
return( DRS_OK);
|
|
}
|
|
|
|
/*
|
|
DRT_Status DR_Task_Run( DRT_Task_Command Command, void *Target_Ptr)
|
|
{
|
|
DRT_Task_Id task_id;
|
|
DRT_Boolean found = DRD_FALSE;
|
|
|
|
|
|
// fprintf( stderr, "Task Run: Called!\n");
|
|
|
|
DRG_Base.Task_Count_Run++;
|
|
|
|
while( found != DRD_TRUE)
|
|
{
|
|
task_id = 0;
|
|
|
|
pthread_mutex_lock( &( DRG_Base.Task_Mutex));
|
|
|
|
while( ( task_id < DRG_Base.Task_Number) && ( found != DRD_TRUE))
|
|
{
|
|
if( DR_TASK_STATUS_WAITING_IS( &( DRG_Base.Task_Tab[task_id])) && DR_TASK_CMD_NONE_IS( &( DRG_Base.Task_Tab[task_id])))
|
|
{
|
|
// pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
// fprintf( stderr, "Task Run: Found (%d)!\n", task_id);
|
|
|
|
if( DR_Task_Id_Run( task_id, Command, Target_Ptr) != DRS_OK)
|
|
{
|
|
fprintf( stderr, "Can't run task !\n");
|
|
|
|
pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
return( DRS_KO);
|
|
}
|
|
|
|
pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
found = DRD_TRUE;
|
|
}
|
|
|
|
task_id++;
|
|
}
|
|
|
|
if( found != DRD_TRUE)
|
|
{
|
|
// fprintf( stderr, "Task Run: Sleeping!\n");
|
|
|
|
DRG_Base.Task_Count_Sleep++;
|
|
|
|
pthread_cond_wait( &( DRG_Base.Task_Cond), &( DRG_Base.Task_Mutex));
|
|
pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
}
|
|
}
|
|
|
|
return( DRS_OK);
|
|
}
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_Task_Wait */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_Task_Wait()
|
|
{
|
|
DRT_Task_Id task_id, count = 0;
|
|
|
|
|
|
pthread_mutex_lock( &( DRG_Base.Task_Mutex));
|
|
|
|
while( count < DRG_Base.Task_Number)
|
|
{
|
|
task_id = 0;
|
|
count = 0;
|
|
|
|
for( task_id = 0; task_id < DRG_Base.Task_Number; task_id++)
|
|
{
|
|
if( DR_TASK_STATUS_WAITING_IS( &( DRG_Base.Task_Tab[task_id])) && DR_TASK_CMD_NONE_IS( &( DRG_Base.Task_Tab[task_id])))
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
|
|
if( count < DRG_Base.Task_Number)
|
|
{
|
|
// DR_Tasks_Dump();
|
|
|
|
pthread_cond_wait( &( DRG_Base.Task_Cond), &( DRG_Base.Task_Mutex));
|
|
}
|
|
}
|
|
|
|
pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
|
|
return( DRS_OK);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_Tasks_Dump */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_Tasks_Dump()
|
|
{
|
|
DRT_Task_Id task_id;
|
|
|
|
|
|
// pthread_mutex_lock( &( DRG_Base.Task_Mutex));
|
|
|
|
LG_LOG_INFO_6( "Task Number: (%d) Task Load Layer: [%s] Task Load Instrument: [%s] Task Load Kit: [%s] Task Sync Kit: [%s] Task Sync Kits: [%s]",
|
|
DRG_Base.Task_Number, DR_BOOLEAN_VALUE_ASCII_GET( DRG_Base.Task_Load_Layer_Flag), DR_BOOLEAN_VALUE_ASCII_GET( DRG_Base.Task_Load_Instrument_Flag), DR_BOOLEAN_VALUE_ASCII_GET( DRG_Base.Task_Load_Kit_Flag), DR_BOOLEAN_VALUE_ASCII_GET( DRG_Base.Task_Sync_Kit_Flag), DR_BOOLEAN_VALUE_ASCII_GET( DRG_Base.Task_Sync_Kits_Flag));
|
|
LG_LOG_INFO_0( "Task Tab:");
|
|
|
|
for( task_id = 0; task_id < DRG_Base.Task_Number; task_id++)
|
|
{
|
|
LG_LOG_INFO_6( " Id: (%02d) Status: [%s] Thread: (%ld) Command: [%s] Target Ptr: [%lx] Count: (%ld)",
|
|
task_id, DR_TASK_STATUS_ASCII_GET( &( DRG_Base.Task_Tab[task_id])), (long)( DRG_Base.Task_Tab[task_id].Thread), DR_TASK_CMD_ASCII_GET( &( DRG_Base.Task_Tab[task_id])), DRG_Base.Task_Tab[task_id].Target_Ptr, DRG_Base.Task_Tab[task_id].Count);
|
|
}
|
|
|
|
LG_LOG_INFO_4( "Task Count Waiting: (%ld) Task Count Run: (%ld) Task Count Sleep: (%ld) Task Count FakeWU: (%ld)", DRG_Base.Task_Count_Waiting, DRG_Base.Task_Count_Run, DRG_Base.Task_Count_Sleep, DRG_Base.Task_Count_FakeWU);
|
|
|
|
// pthread_mutex_unlock( &( DRG_Base.Task_Mutex));
|
|
|
|
return( DRS_OK);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_DataStruct_Init */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_DataStruct_Init( DRT_SampleRate SampleRate, DRT_Task_Id Task_Number)
|
|
{
|
|
NDT_Status nd_status;
|
|
DRT_Task_Id task_id;
|
|
|
|
|
|
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( &( DRG_Base.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)
|
|
{
|
|
fprintf( stderr, "Kit_DS: ND_DataStruct_Open() failed (%d)!\n", nd_status);
|
|
return( DRS_KO);
|
|
}
|
|
|
|
DRG_Base.SampleRate = SampleRate;
|
|
/*
|
|
DRG_Base.Velocity_Ignore_Flag = DRD_VELOCITY_IGNORE_FLAG_DEFAULT;
|
|
DRG_Base.Note_Off_Ignore_Flag = DRD_NOTE_OFF_IGNORE_FLAG_DEFAULT;
|
|
DRG_Base.Velocity_Ignore_Note = DRD_VELOCITY_IGNORE_NOTE_DEFAULT;
|
|
DRG_Base.Note_Off_Ignore_Note = DRD_NOTE_OFF_IGNORE_NOTE_DEFAULT;
|
|
*/
|
|
|
|
DRG_Base.Channel_Id_Ptr = NULL;
|
|
DRG_Base.Base_Note_Ptr = NULL;
|
|
DRG_Base.Velocity_Ignore_Note_Ptr = NULL;
|
|
DRG_Base.Note_Off_Ignore_Note_Ptr = NULL;
|
|
DRG_Base.Velocity_Ignore_Flag_Ptr = NULL;
|
|
DRG_Base.Note_Off_Ignore_Flag_Ptr = NULL;
|
|
DRG_Base.Task_Number = Task_Number;
|
|
DRG_Base.Task_Load_Layer_Flag = DRD_TASK_LOAD_LAYER_DEFAULT;
|
|
DRG_Base.Task_Load_Instrument_Flag = DRD_TASK_LOAD_INSTRUMENT_DEFAULT;
|
|
DRG_Base.Task_Load_Kit_Flag = DRD_TASK_LOAD_KIT_DEFAULT;
|
|
DRG_Base.Task_Sync_Kit_Flag = DRD_TASK_SYNC_KIT_DEFAULT;
|
|
DRG_Base.Task_Sync_Kits_Flag = DRD_TASK_SYNC_KITS_DEFAULT;
|
|
DRG_Base.Task_Count_Waiting = 0L;
|
|
DRG_Base.Task_Count_Run = 0L;
|
|
DRG_Base.Task_Count_Sleep = 0L;
|
|
DRG_Base.Task_Count_FakeWU = 0L;
|
|
|
|
if( ( DRG_Base.Task_Tab = malloc( sizeof( DRT_Task) * Task_Number)) == NULL)
|
|
{
|
|
fprintf( stderr, "Can't allocate task tab!\n");
|
|
return( NDS_KO);
|
|
}
|
|
else
|
|
{
|
|
if( pthread_mutex_init( &( DRG_Base.Task_Mutex), 0))
|
|
{
|
|
fprintf( stderr, "Could not initialize global task mutex!\n");
|
|
return( NDS_KO);
|
|
}
|
|
|
|
if( pthread_cond_init( &( DRG_Base.Task_Cond), 0))
|
|
{
|
|
fprintf( stderr, "Could not initialize global task cond!\n");
|
|
return( NDS_KO);
|
|
}
|
|
|
|
for( task_id = 0; task_id < Task_Number; task_id++)
|
|
{
|
|
DRG_Base.Task_Tab[task_id].Status = DRD_TASK_STATUS_UNSPAWNED;
|
|
DRG_Base.Task_Tab[task_id].Command = DRD_TASK_CMD_TASK_SPAWN;
|
|
DRG_Base.Task_Tab[task_id].Target_Ptr = NULL;
|
|
DRG_Base.Task_Tab[task_id].Count = 0L;
|
|
|
|
if( pthread_cond_init( &( DRG_Base.Task_Tab[task_id].Cond), 0))
|
|
{
|
|
fprintf( stderr, "Could not initialize task cond!\n");
|
|
return( NDS_KO);
|
|
}
|
|
|
|
if( pthread_create( &(DRG_Base.Task_Tab[task_id].Thread), 0, (void * (*)(void *))DR_Task_Thread, NULL))
|
|
{
|
|
fprintf( stderr, "Could not initialize task thread!\n");
|
|
return( NDS_KO);
|
|
}
|
|
}
|
|
}
|
|
|
|
return( DRS_OK);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/* DR_DataStruct_DeInit */
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
DRT_Status DR_DataStruct_DeInit()
|
|
{
|
|
NDT_Status nd_status;
|
|
DRT_Task_Id task_id;
|
|
|
|
|
|
for( task_id = 0; task_id < DRG_Base.Task_Number; task_id++)
|
|
{
|
|
if( DR_Task_Id_Kill( task_id) != DRS_OK)
|
|
{
|
|
printf( "Can't kill task: (%d)!\n", task_id);
|
|
return( NDS_KO);
|
|
}
|
|
}
|
|
|
|
// sleep(5);
|
|
|
|
if( ( nd_status = ND_DataStruct_Close( DRG_Base.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);
|
|
}
|