Changeset 378
- Timestamp:
- 01/21/07 04:05:19 (17 years ago)
- Files:
-
- trunk/libfreebob/src/bebob/bebob_avdevice.cpp (modified) (3 diffs)
- trunk/libfreebob/src/bebob/bebob_avdevice.h (modified) (3 diffs)
- trunk/libfreebob/src/bebob/bebob_avdevice_subunit.cpp (modified) (1 diff)
- trunk/libfreebob/src/bebob/bebob_functionblock.cpp (modified) (23 diffs)
- trunk/libfreebob/src/bebob/bebob_functionblock.h (modified) (10 diffs)
- trunk/libfreebob/src/libfreebobavc/avc_extended_subunit_info.h (modified) (1 diff)
- trunk/libfreebob/src/libfreebobavc/avc_function_block.h (modified) (5 diffs)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
trunk/libfreebob/src/bebob/bebob_avdevice.cpp
r376 r378 1 1 /* bebob_avdevice.cpp 2 * Copyright (C) 2005,06 by Daniel Wagner2 * Copyright (C) 2005,06,07 by Daniel Wagner 3 3 * 4 4 * This file is part of FreeBoB. … … 1232 1232 } 1233 1233 1234 1235 template <typename T> bool serializeVector( Glib::ustring path,1236 Util::IOSerialize& ser,1237 T& vec )1238 {1239 bool result = true; // if vec.size() == 01240 int i = 0;1241 for ( typename T::iterator it = vec.begin(); it != vec.end(); ++it ) {1242 std::ostringstream strstrm;1243 strstrm << path << i;1244 result &= ( *it )->serialize( strstrm.str() + "/", ser );1245 i++;1246 }1247 return result;1248 }1249 1250 template <typename T, typename VT> bool deserializeVector( Glib::ustring path,1251 Util::IODeserialize& deser,1252 AvDevice& avDevice,1253 VT& vec )1254 {1255 int i = 0;1256 bool bFinished = false;1257 do {1258 std::ostringstream strstrm;1259 strstrm << path << i;1260 T* ptr = T::deserialize( strstrm.str() + "/",1261 deser,1262 avDevice );1263 if ( ptr ) {1264 vec.push_back( ptr );1265 i++;1266 } else {1267 bFinished = true;1268 }1269 } while ( !bFinished );1270 1271 return true;1272 }1273 1274 1234 static bool 1275 1235 deserializeAvPlugUpdateConnections( Glib::ustring path, … … 1290 1250 bool 1291 1251 AvDevice::serialize( Glib::ustring 1292 basePath, Util::IOSerialize& ser ) 1252 basePath, Util::IOSerialize& ser ) const 1293 1253 { 1294 1254 bool result; trunk/libfreebob/src/bebob/bebob_avdevice.h
r375 r378 40 40 #include "iavdevice.h" 41 41 42 #include <sstream> 43 42 44 class ConfigRom; 43 45 class Ieee1394Service; … … 99 101 bool setActiveSync( const SyncInfo& syncInfo ); 100 102 101 bool serialize( Glib::ustring basePath, Util::IOSerialize& ser ) ;103 bool serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const; 102 104 static AvDevice* deserialize( Glib::ustring basePath, 103 105 Util::IODeserialize& deser, … … 168 170 }; 169 171 172 template <typename T> bool serializeVector( Glib::ustring path, 173 Util::IOSerialize& ser, 174 const T& vec ) 175 { 176 bool result = true; // if vec.size() == 0 177 int i = 0; 178 for ( typename T::const_iterator it = vec.begin(); it != vec.end(); ++it ) { 179 std::ostringstream strstrm; 180 strstrm << path << i; 181 result &= ( *it )->serialize( strstrm.str() + "/", ser ); 182 i++; 183 } 184 return result; 170 185 } 171 186 187 template <typename T, typename VT> bool deserializeVector( Glib::ustring path, 188 Util::IODeserialize& deser, 189 AvDevice& avDevice, 190 VT& vec ) 191 { 192 int i = 0; 193 bool bFinished = false; 194 do { 195 std::ostringstream strstrm; 196 strstrm << path << i << "/"; 197 T* ptr = T::deserialize( strstrm.str(), 198 deser, 199 avDevice ); 200 if ( ptr ) { 201 vec.push_back( ptr ); 202 i++; 203 } else { 204 bFinished = true; 205 } 206 } while ( !bFinished ); 207 208 return true; 209 } 210 211 } 212 172 213 #endif trunk/libfreebob/src/bebob/bebob_avdevice_subunit.cpp
r376 r378 535 535 FunctionBlock* pFB = FunctionBlock::deserialize( strstrm.str(), 536 536 deser, 537 avDevice ); 537 avDevice, 538 *this ); 538 539 if ( pFB ) { 539 540 m_functions.push_back( pFB ); trunk/libfreebob/src/bebob/bebob_functionblock.cpp
r376 r378 24 24 #include "configrom.h" 25 25 26 namespace BeBoB { 27 28 IMPL_DEBUG_MODULE( FunctionBlock, FunctionBlock, DEBUG_LEVEL_NORMAL ); 29 30 FunctionBlock::FunctionBlock( 26 27 IMPL_DEBUG_MODULE( BeBoB::FunctionBlock, BeBoB::FunctionBlock, DEBUG_LEVEL_NORMAL ); 28 29 BeBoB::FunctionBlock::FunctionBlock( 31 30 AvDeviceSubunit& subunit, 32 31 function_block_type_t type, 32 function_block_type_t subtype, 33 33 function_block_id_t id, 34 34 ESpecialPurpose purpose, … … 38 38 : m_subunit( &subunit ) 39 39 , m_type( type ) 40 , m_subtype( subtype ) 40 41 , m_id( id ) 41 42 , m_purpose( purpose ) … … 47 48 } 48 49 49 FunctionBlock::FunctionBlock( const FunctionBlock& rhs )50 BeBoB::FunctionBlock::FunctionBlock( const FunctionBlock& rhs ) 50 51 : m_subunit( rhs.m_subunit ) 51 52 , m_type( rhs.m_type ) 53 , m_subtype( rhs.m_subtype ) 52 54 , m_id( rhs.m_id ) 53 55 , m_purpose( rhs.m_purpose ) … … 58 60 } 59 61 60 FunctionBlock::~FunctionBlock() 62 BeBoB::FunctionBlock::FunctionBlock() 63 { 64 } 65 66 BeBoB::FunctionBlock::~FunctionBlock() 61 67 { 62 68 for ( AvPlugVector::iterator it = m_plugs.begin(); … … 70 76 71 77 bool 72 FunctionBlock::discover()78 BeBoB::FunctionBlock::discover() 73 79 { 74 80 debugOutput( DEBUG_LEVEL_VERBOSE, … … 95 101 96 102 bool 97 FunctionBlock::discoverPlugs( AvPlug::EAvPlugDirection plugDirection,98 plug_id_t plugMaxId )103 BeBoB::FunctionBlock::discoverPlugs( AvPlug::EAvPlugDirection plugDirection, 104 plug_id_t plugMaxId ) 99 105 { 100 106 for ( int plugId = 0; plugId < plugMaxId; ++plugId ) { … … 128 134 129 135 bool 130 FunctionBlock::discoverConnections()136 BeBoB::FunctionBlock::discoverConnections() 131 137 { 132 138 debugOutput( DEBUG_LEVEL_VERBOSE, … … 148 154 149 155 bool 150 FunctionBlock::serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const 151 { 152 int dummy = 42; 153 return ser.write( basePath + "dummy", dummy ); 154 } 155 156 FunctionBlock* 157 FunctionBlock::deserialize( Glib::ustring basePath, 158 Util::IODeserialize& deser, 159 AvDevice& avDevice ) 160 { 156 serializeAvPlugVector( Glib::ustring basePath, 157 Util::IOSerialize& ser, 158 const BeBoB::AvPlugVector& vec ) 159 { 160 bool result = true; 161 int i = 0; 162 for ( BeBoB::AvPlugVector::const_iterator it = vec.begin(); 163 it != vec.end(); 164 ++it ) 165 { 166 std::ostringstream strstrm; 167 strstrm << basePath << i; 168 result &= ser.write( strstrm.str(), ( *it )->getGlobalId() ); 169 i++; 170 } 171 return result; 172 } 173 174 bool 175 deserializeAvPlugVector( Glib::ustring basePath, 176 Util::IODeserialize& deser, 177 BeBoB::AvDevice& avDevice, 178 BeBoB::AvPlugVector& vec ) 179 { 180 int i = 0; 181 bool bFinished = false; 182 bool result = true; 183 do { 184 plug_id_t plugId; 185 std::ostringstream strstrm; 186 strstrm << basePath << i; 187 188 result &= deser.read( strstrm.str(), plugId ); 189 BeBoB::AvPlug* pPlug = avDevice.getPlugManager().getPlug( plugId ); 190 191 if ( pPlug ) { 192 vec.push_back( pPlug ); 193 i++; 194 } else { 195 bFinished = true; 196 } 197 } while ( !bFinished ); 198 199 return result; 200 } 201 202 bool 203 BeBoB::FunctionBlock::serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const 204 { 205 bool result; 206 207 result = ser.write( basePath + "m_type", m_type ); 208 result &= ser.write( basePath + "m_subtype", m_subtype ); 209 result &= ser.write( basePath + "m_id", m_id ); 210 result &= ser.write( basePath + "m_purpose", m_purpose ); 211 result &= ser.write( basePath + "m_nrOfInputPlugs", m_nrOfInputPlugs ); 212 result &= ser.write( basePath + "m_nrOfOutputPlugs", m_nrOfOutputPlugs ); 213 result &= ser.write( basePath + "m_verbose", m_verbose ); 214 result &= serializeAvPlugVector( basePath + "m_plugs", ser, m_plugs ); 215 216 return result; 217 } 218 219 BeBoB::FunctionBlock* 220 BeBoB::FunctionBlock::deserialize( Glib::ustring basePath, 221 Util::IODeserialize& deser, 222 AvDevice& avDevice, 223 AvDeviceSubunit& subunit ) 224 { 225 bool result; 226 function_block_type_t type; 227 function_block_type_t subtype; 228 FunctionBlock* pFB = 0; 229 230 result = deser.read( basePath + "m_type", type ); 231 result &= deser.read( basePath + "m_subtype", subtype ); 232 if ( !result ) { 233 return 0; 234 } 235 236 switch ( type ) { 237 case ExtendedSubunitInfoCmd::eFBT_AudioSubunitSelector: 238 pFB = new FunctionBlockSelector; 239 break; 240 case ExtendedSubunitInfoCmd::eFBT_AudioSubunitFeature: 241 pFB = new FunctionBlockFeature; 242 break; 243 case ExtendedSubunitInfoCmd::eFBT_AudioSubunitProcessing: 244 if ( subtype == ExtendedSubunitInfoCmd::ePT_EnhancedMixer ) { 245 pFB = new FunctionBlockEnhancedMixer; 246 } else { 247 pFB = new FunctionBlockProcessing; 248 } 249 break; 250 case ExtendedSubunitInfoCmd::eFBT_AudioSubunitCodec: 251 pFB = new FunctionBlockCodec; 252 break; 253 default: 254 pFB = 0; 255 } 256 257 if ( !pFB ) { 258 return 0; 259 } 260 261 pFB->m_subunit = &subunit; 262 pFB->m_type = type; 263 pFB->m_subtype = subtype; 264 265 result &= deser.read( basePath + "m_id", pFB->m_id ); 266 result &= deser.read( basePath + "m_purpose", pFB->m_purpose ); 267 result &= deser.read( basePath + "m_nrOfInputPlugs", pFB->m_nrOfInputPlugs ); 268 result &= deser.read( basePath + "m_nrOfOutputPlugs", pFB->m_nrOfOutputPlugs ); 269 result &= deser.read( basePath + "m_verbose", pFB->m_verbose ); 270 result &= deserializeAvPlugVector( basePath + "m_plugs", deser, avDevice, pFB->m_plugs ); 271 161 272 return 0; 162 273 } … … 164 275 /////////////////////// 165 276 166 FunctionBlockSelector::FunctionBlockSelector(277 BeBoB::FunctionBlockSelector::FunctionBlockSelector( 167 278 AvDeviceSubunit& subunit, 168 279 function_block_id_t id, … … 173 284 : FunctionBlock( subunit, 174 285 eFBT_AudioSubunitSelector, 286 0, 175 287 id, 176 288 purpose, … … 181 293 } 182 294 183 FunctionBlockSelector::FunctionBlockSelector(295 BeBoB::FunctionBlockSelector::FunctionBlockSelector( 184 296 const FunctionBlockSelector& rhs ) 185 297 : FunctionBlock( rhs ) … … 187 299 } 188 300 189 FunctionBlockSelector::~FunctionBlockSelector() 301 BeBoB::FunctionBlockSelector::FunctionBlockSelector() 302 : FunctionBlock() 303 { 304 } 305 306 BeBoB::FunctionBlockSelector::~FunctionBlockSelector() 190 307 { 191 308 } 192 309 193 310 const char* 194 FunctionBlockSelector::getName()311 BeBoB::FunctionBlockSelector::getName() 195 312 { 196 313 return "Selector"; 197 314 } 198 315 316 bool 317 BeBoB::FunctionBlockSelector::serializeChild( Glib::ustring basePath, 318 Util::IOSerialize& ser ) const 319 { 320 return true; 321 } 322 323 bool 324 BeBoB::FunctionBlockSelector::deserializeChild( Glib::ustring basePath, 325 Util::IODeserialize& deser, 326 AvDevice& avDevice ) 327 { 328 return true; 329 } 330 199 331 /////////////////////// 200 332 201 FunctionBlockFeature::FunctionBlockFeature(333 BeBoB::FunctionBlockFeature::FunctionBlockFeature( 202 334 AvDeviceSubunit& subunit, 203 335 function_block_id_t id, … … 208 340 : FunctionBlock( subunit, 209 341 eFBT_AudioSubunitFeature, 342 0, 210 343 id, 211 344 purpose, … … 216 349 } 217 350 218 FunctionBlockFeature::FunctionBlockFeature(351 BeBoB::FunctionBlockFeature::FunctionBlockFeature( 219 352 const FunctionBlockFeature& rhs ) 220 353 : FunctionBlock( rhs ) … … 222 355 } 223 356 224 FunctionBlockFeature::~FunctionBlockFeature() 357 BeBoB::FunctionBlockFeature::FunctionBlockFeature() 358 : FunctionBlock() 359 { 360 } 361 362 BeBoB::FunctionBlockFeature::~FunctionBlockFeature() 225 363 { 226 364 } 227 365 228 366 const char* 229 FunctionBlockFeature::getName()367 BeBoB::FunctionBlockFeature::getName() 230 368 { 231 369 return "Feature"; 232 370 } 233 371 372 bool 373 BeBoB::FunctionBlockFeature::serializeChild( Glib::ustring basePath, 374 Util::IOSerialize& ser ) const 375 { 376 return true; 377 } 378 379 bool 380 BeBoB::FunctionBlockFeature::deserializeChild( Glib::ustring basePath, 381 Util::IODeserialize& deser, 382 AvDevice& avDevice ) 383 { 384 return true; 385 } 386 234 387 /////////////////////// 235 388 236 FunctionBlockEnhancedMixer::FunctionBlockEnhancedMixer(389 BeBoB::FunctionBlockEnhancedMixer::FunctionBlockEnhancedMixer( 237 390 AvDeviceSubunit& subunit, 238 391 function_block_id_t id, … … 243 396 : FunctionBlock( subunit, 244 397 eFBT_AudioSubunitProcessing, 398 ExtendedSubunitInfoCmd::ePT_EnhancedMixer, 245 399 id, 246 400 purpose, … … 251 405 } 252 406 253 FunctionBlockEnhancedMixer::FunctionBlockEnhancedMixer(407 BeBoB::FunctionBlockEnhancedMixer::FunctionBlockEnhancedMixer( 254 408 const FunctionBlockEnhancedMixer& rhs ) 255 409 : FunctionBlock( rhs ) … … 257 411 } 258 412 259 FunctionBlockEnhancedMixer::~FunctionBlockEnhancedMixer() 413 BeBoB::FunctionBlockEnhancedMixer::FunctionBlockEnhancedMixer() 414 : FunctionBlock() 415 { 416 } 417 418 BeBoB::FunctionBlockEnhancedMixer::~FunctionBlockEnhancedMixer() 260 419 { 261 420 } 262 421 263 422 const char* 264 FunctionBlockEnhancedMixer::getName()423 BeBoB::FunctionBlockEnhancedMixer::getName() 265 424 { 266 425 return "EnhancedMixer"; 267 426 } 268 427 428 bool 429 BeBoB::FunctionBlockEnhancedMixer::serializeChild( Glib::ustring basePath, 430 Util::IOSerialize& ser ) const 431 { 432 return true; 433 } 434 435 bool 436 BeBoB::FunctionBlockEnhancedMixer::deserializeChild( Glib::ustring basePath, 437 Util::IODeserialize& deser, 438 AvDevice& avDevice ) 439 { 440 return true; 441 } 442 269 443 /////////////////////// 270 444 271 FunctionBlockProcessing::FunctionBlockProcessing(445 BeBoB::FunctionBlockProcessing::FunctionBlockProcessing( 272 446 AvDeviceSubunit& subunit, 273 447 function_block_id_t id, … … 278 452 : FunctionBlock( subunit, 279 453 eFBT_AudioSubunitProcessing, 454 0, 280 455 id, 281 456 purpose, … … 286 461 } 287 462 288 FunctionBlockProcessing::FunctionBlockProcessing(463 BeBoB::FunctionBlockProcessing::FunctionBlockProcessing( 289 464 const FunctionBlockProcessing& rhs ) 290 465 : FunctionBlock( rhs ) … … 292 467 } 293 468 294 FunctionBlockProcessing::~FunctionBlockProcessing() 469 BeBoB::FunctionBlockProcessing::FunctionBlockProcessing() 470 : FunctionBlock() 471 { 472 } 473 474 BeBoB::FunctionBlockProcessing::~FunctionBlockProcessing() 295 475 { 296 476 } 297 477 298 478 const char* 299 FunctionBlockProcessing::getName()479 BeBoB::FunctionBlockProcessing::getName() 300 480 { 301 481 return "Dummy Processing"; 302 482 } 303 483 484 bool 485 BeBoB::FunctionBlockProcessing::serializeChild( Glib::ustring basePath, 486 Util::IOSerialize& ser ) const 487 { 488 return true; 489 } 490 491 bool 492 BeBoB::FunctionBlockProcessing::deserializeChild( Glib::ustring basePath, 493 Util::IODeserialize& deser, 494 AvDevice& avDevice ) 495 { 496 return true; 497 } 498 304 499 /////////////////////// 305 500 306 FunctionBlockCodec::FunctionBlockCodec(501 BeBoB::FunctionBlockCodec::FunctionBlockCodec( 307 502 AvDeviceSubunit& subunit, 308 503 function_block_id_t id, … … 313 508 : FunctionBlock( subunit, 314 509 eFBT_AudioSubunitCodec, 510 0, 315 511 id, 316 512 purpose, … … 321 517 } 322 518 323 FunctionBlockCodec::FunctionBlockCodec( const FunctionBlockCodec& rhs )519 BeBoB::FunctionBlockCodec::FunctionBlockCodec( const FunctionBlockCodec& rhs ) 324 520 : FunctionBlock( rhs ) 325 521 { 326 522 } 327 523 328 FunctionBlockCodec::~FunctionBlockCodec() 524 BeBoB::FunctionBlockCodec::FunctionBlockCodec() 525 : FunctionBlock() 526 { 527 } 528 529 BeBoB::FunctionBlockCodec::~FunctionBlockCodec() 329 530 { 330 531 } 331 532 332 533 const char* 333 FunctionBlockCodec::getName()534 BeBoB::FunctionBlockCodec::getName() 334 535 { 335 536 return "Dummy Codec"; 336 537 } 337 538 338 } 539 bool 540 BeBoB::FunctionBlockCodec::serializeChild( Glib::ustring basePath, 541 Util::IOSerialize& ser ) const 542 { 543 return true; 544 } 545 546 bool 547 BeBoB::FunctionBlockCodec::deserializeChild( Glib::ustring basePath, 548 Util::IODeserialize& deser, 549 AvDevice& avDevice ) 550 { 551 return true; 552 } trunk/libfreebob/src/bebob/bebob_functionblock.h
r376 r378 1 1 /* bebob_functionblock.h 2 * Copyright (C) 2006 by Daniel Wagner2 * Copyright (C) 2006,07 by Daniel Wagner 3 3 * 4 4 * This file is part of FreeBoB. … … 49 49 FunctionBlock( AvDeviceSubunit& subunit, 50 50 function_block_type_t type, 51 function_block_type_t subtype, 51 52 function_block_id_t id, 52 53 ESpecialPurpose purpose, … … 55 56 int verbose ); 56 57 FunctionBlock( const FunctionBlock& rhs ); 58 FunctionBlock(); 57 59 virtual ~FunctionBlock(); 58 60 … … 65 67 static FunctionBlock* deserialize( Glib::ustring basePath, 66 68 Util::IODeserialize& deser, 67 AvDevice& avDevice ); 69 AvDevice& avDevice, 70 AvDeviceSubunit& subunit); 68 71 protected: 69 72 bool discoverPlugs( AvPlug::EAvPlugDirection plugDirection, … … 73 76 AvDeviceSubunit* m_subunit; 74 77 function_block_type_t m_type; 78 function_block_type_t m_subtype; 75 79 function_block_id_t m_id; 76 80 ESpecialPurpose m_purpose; 77 81 no_of_input_plugs_t m_nrOfInputPlugs; 78 82 no_of_output_plugs_t m_nrOfOutputPlugs; 79 int m_verbose; 80 81 AvPlugVector m_plugs; 83 int m_verbose; 84 AvPlugVector m_plugs; 82 85 83 86 DECLARE_DEBUG_MODULE; … … 99 102 int verbose); 100 103 FunctionBlockSelector( const FunctionBlockSelector& rhs ); 104 FunctionBlockSelector(); 101 105 virtual ~FunctionBlockSelector(); 102 106 103 107 virtual const char* getName(); 108 109 protected: 110 virtual bool serializeChild( Glib::ustring basePath, 111 Util::IOSerialize& ser ) const; 112 virtual bool deserializeChild( Glib::ustring basePath, 113 Util::IODeserialize& deser, 114 AvDevice& avDevice ); 104 115 }; 105 116 … … 116 127 int verbose); 117 128 FunctionBlockFeature( const FunctionBlockFeature& rhs ); 129 FunctionBlockFeature(); 118 130 virtual ~FunctionBlockFeature(); 119 131 120 132 virtual const char* getName(); 133 134 protected: 135 virtual bool serializeChild( Glib::ustring basePath, 136 Util::IOSerialize& ser ) const; 137 virtual bool deserializeChild( Glib::ustring basePath, 138 Util::IODeserialize& deser, 139 AvDevice& avDevice ); 121 140 }; 122 141 … … 132 151 no_of_output_plugs_t nrOfOutputPlugs, 133 152 int verbose ); 153 FunctionBlockEnhancedMixer(); 134 154 FunctionBlockEnhancedMixer( const FunctionBlockEnhancedMixer& rhs ); 135 155 virtual ~FunctionBlockEnhancedMixer(); 136 156 137 157 virtual const char* getName(); 158 159 protected: 160 virtual bool serializeChild( Glib::ustring basePath, 161 Util::IOSerialize& ser ) const; 162 virtual bool deserializeChild( Glib::ustring basePath, 163 Util::IODeserialize& deser, 164 AvDevice& avDevice ); 138 165 }; 139 166 … … 150 177 int verbose ); 151 178 FunctionBlockProcessing( const FunctionBlockProcessing& rhs ); 179 FunctionBlockProcessing(); 152 180 virtual ~FunctionBlockProcessing(); 153 181 154 182 virtual const char* getName(); 183 184 protected: 185 virtual bool serializeChild( Glib::ustring basePath, 186 Util::IOSerialize& ser ) const; 187 virtual bool deserializeChild( Glib::ustring basePath, 188 Util::IODeserialize& deser, 189 AvDevice& avDevice ); 155 190 }; 156 191 … … 167 202 int verbose); 168 203 FunctionBlockCodec( const FunctionBlockCodec& rhs ); 204 FunctionBlockCodec(); 169 205 virtual ~FunctionBlockCodec(); 170 206 171 207 virtual const char* getName(); 208 209 protected: 210 virtual bool serializeChild( Glib::ustring basePath, 211 Util::IOSerialize& ser ) const; 212 virtual bool deserializeChild( Glib::ustring basePath, 213 Util::IODeserialize& deser, 214 AvDevice& avDevice ); 172 215 }; 173 216 trunk/libfreebob/src/libfreebobavc/avc_extended_subunit_info.h
r375 r378 66 66 67 67 enum EProcessingType { 68 ePT_Unknown = 0x00, 68 69 ePT_Mixer = 0x01, 69 70 ePT_Generic = 0x02, trunk/libfreebob/src/libfreebobavc/avc_function_block.h
r375 r378 91 91 // Control selector encoding 92 92 enum EControlSelectorEncoding { 93 eCSE_Selector_Unknown = 0x00, 93 94 eCSE_Selector_Selector = 0x01, 94 95 }; … … 115 116 // Control selector encoding 116 117 enum EControlSelectorEncoding { 118 eCSE_Feature_Unknown = 0x00, 117 119 eCSE_Feature_Mute = 0x01, 118 120 eCSE_Feature_Volume = 0x02, … … 163 165 // Control selector encoding 164 166 enum EControlSelectorEncoding { 167 eCSE_Processing_Unknown = 0x00, 165 168 eCSE_Processing_Enable = 0x01, 166 169 eCSE_Processing_Mode = 0x02, … … 168 171 eCSE_Processing_EnhancedMixer = 0xf1, 169 172 170 // lots of definition missing173 // lots of definitions missing 171 174 172 175 }; … … 197 200 // CODEC type endcoding 198 201 enum ECodecTypeEncoding { 202 eCTE_Unknown = 0x00, 199 203 eCTE_Ac3Decoder = 0x01, 200 204 eCTE_MpegDecoder = 0x02,