Changeset 4339:39115e48e1c7 in roaraudio


Ignore:
Timestamp:
09/13/10 14:18:04 (14 years ago)
Author:
phi
Branch:
default
Phase:
public
Message:

added roar_event_to_blob() and roar_event_from_blob()

Files:
3 edited

Legend:

Unmodified
Added
Removed
  • include/libroar/notify.h

    r4321 r4339  
    3939#include "libroar.h" 
    4040 
    41 #define ROAR_EVENT_FLAG_NONE        0x00000000 
    42 #define ROAR_EVENT_FLAG_NETTRANS    0x00000001 
    43 #define ROAR_EVENT_FLAG_PROXYEVENT  0x00000002 
     41#define ROAR_EVENT_FLAG_NONE        ROAR_EVENT_NETFLAG_NONE 
     42#define ROAR_EVENT_FLAG_NETTRANS    ROAR_EVENT_NETFLAG_DATA 
     43#define ROAR_EVENT_FLAG_PROXYEVENT  ROAR_EVENT_NETFLAG_PROXYEVENT 
    4444 
    4545struct roar_event { 
     
    8080#define roar_notify_core_emit_snoargs(event,emitter,target,target_type) roar_notify_core_emit_simple((event),(emitter),(target),(target_type),-1,-1,NULL,0) 
    8181 
     82int roar_event_to_blob(struct roar_event * event, void * blob, size_t * len); 
     83int roar_event_from_blob(struct roar_event * event, void * blob, size_t * len); 
     84 
    8285#endif 
    8386 
  • include/roaraudio/notify.h

    r4335 r4339  
    2929#ifndef _ROARAUDIO_NOTIFY_H_ 
    3030#define _ROARAUDIO_NOTIFY_H_ 
     31 
     32#define ROAR_EVENT_NETFLAG_NONE        0x00000000 
     33#define ROAR_EVENT_NETFLAG_DATA        0x00000001 
     34#define ROAR_EVENT_NETFLAG_PROXYEVENT  0x00000002 
    3135 
    3236#define ROAR_NOTIFY_SPECIAL       0xffffffff 
  • libroar/notify.c

    r4337 r4339  
    331331} 
    332332 
     333 
     334int roar_event_to_blob(struct roar_event * event, void * blob, size_t * len) { 
     335 size_t needed_len = (2 * 4) + (4 * 2); 
     336 uint32_t * u32 = blob; 
     337 uint16_t * u16 = blob; 
     338 size_t data_offset_neg = 0; 
     339 
     340 u16 += 4; 
     341 
     342 // error checking: 
     343 if ( event == NULL || blob == NULL || len == NULL ) 
     344  return -1; 
     345 
     346 if ( *len == 0 ) 
     347  return -1; 
     348 
     349 // calc and check length: 
     350 if ( event->flags & ROAR_EVENT_FLAG_PROXYEVENT ) 
     351  needed_len += 4; 
     352 
     353 if ( event->flags & ROAR_EVENT_FLAG_NETTRANS ) { 
     354 
     355  // this is not a real maximum but a value good to detect all kinds of errors. 
     356  // a notify event should not be longer anyway. 
     357  if ( event->arg2_len > 32768 ) 
     358   return -1; 
     359 
     360  needed_len += 4; 
     361  if ( event->arg2_len > 0 ) { 
     362    needed_len += event->arg2_len; 
     363    data_offset_neg = event->arg2_len; 
     364  } 
     365 } 
     366 
     367 if ( *len < needed_len ) 
     368  return -1; 
     369 
     370 *len = 0; 
     371 
     372 // fill in the data... 
     373 memset(blob, 0, needed_len); 
     374 
     375 u32[1] = ROAR_HOST2NET32(0); 
     376 
     377 if ( event->flags & ROAR_EVENT_FLAG_PROXYEVENT ) { 
     378  u32[0] |= ROAR_HOST2NET32(ROAR_EVENT_NETFLAG_PROXYEVENT); 
     379  u16 += 2; 
     380 } 
     381 
     382 if ( event->flags & ROAR_EVENT_FLAG_NETTRANS ) { 
     383  u32[0] |= ROAR_HOST2NET32(ROAR_EVENT_NETFLAG_DATA); 
     384 } 
     385 
     386 u32[1] = ROAR_HOST2NET32(event->event); 
     387 
     388 if ( event->flags & ROAR_EVENT_FLAG_PROXYEVENT ) 
     389  u32[2] = ROAR_HOST2NET32(event->event_proxy); 
     390 
     391 u16[0] = ROAR_HOST2NET16(event->emitter); 
     392 u16[1] = ROAR_HOST2NET16(event->target); 
     393 u16[2] = ROAR_HOST2NET16(event->target_type); 
     394 if ( event->flags & ROAR_EVENT_FLAG_NETTRANS ) { 
     395  u16[3] = ROAR_HOST2NET16(event->arg2_len); 
     396  u16[4] = ROAR_HOST2NET16(event->arg0); 
     397  u16[5] = ROAR_HOST2NET16(event->arg1); 
     398 } else { 
     399  u16[3] = ROAR_HOST2NET16(0); 
     400 } 
     401 
     402 memcpy(blob + needed_len - data_offset_neg, event->arg2, event->arg2_len); 
     403 
     404 *len = needed_len; 
     405 
     406 return 0; 
     407} 
     408 
     409int roar_event_from_blob(struct roar_event * event, void * blob, size_t * len) { 
     410 size_t needed_len = (2 * 4) + (4 * 2); 
     411 uint32_t * u32 = blob; 
     412 uint16_t * u16 = blob; 
     413 uint32_t flags; 
     414 
     415 u16 += 4; 
     416 
     417 // error checking: 
     418 if ( event == NULL || blob == NULL || len == NULL ) 
     419  return -1; 
     420 
     421 // check for minimum length. 
     422 if ( *len < needed_len ) 
     423  return -1; 
     424 
     425 flags = ROAR_NET2HOST32(u32[0]); 
     426 
     427#if 0 
     428 if ( event->flags & ROAR_EVENT_FLAG_PROXYEVENT ) { 
     429  u32[0] |= ROAR_HOST2NET32(ROAR_EVENT_NETFLAG_PROXYEVENT); 
     430  u16 += 2; 
     431 } 
     432 
     433 if ( event->flags & ROAR_EVENT_FLAG_NETTRANS ) { 
     434  u32[0] |= ROAR_HOST2NET32(ROAR_EVENT_NETFLAG_DATA); 
     435 } 
     436#endif 
     437 
     438 if ( flags & ROAR_EVENT_NETFLAG_PROXYEVENT ) { 
     439  needed_len += 4; 
     440  u16 += 2; 
     441 } 
     442 
     443 if ( flags & ROAR_EVENT_NETFLAG_DATA ) { 
     444  needed_len += 4; 
     445 } 
     446 
     447 // do we have a full header? 
     448 if ( *len < needed_len ) 
     449  return -1; 
     450 
     451 needed_len += ROAR_NET2HOST16(u16[3]); 
     452 
     453 // is all of the event complet? 
     454 if ( *len < needed_len ) 
     455  return -1; 
     456 
     457 // now we know everything is complet we can start to extract data... 
     458 
     459 *len = 0; 
     460 
     461 memset(event, 0, sizeof(struct roar_event)); 
     462 
     463 if ( flags & ROAR_EVENT_NETFLAG_PROXYEVENT ) { 
     464  flags -= ROAR_EVENT_NETFLAG_PROXYEVENT; 
     465  event->flags |= ROAR_EVENT_FLAG_PROXYEVENT; 
     466 } 
     467 
     468 if ( flags & ROAR_EVENT_NETFLAG_DATA ) { 
     469  flags -= ROAR_EVENT_NETFLAG_DATA; 
     470  event->flags |= ROAR_EVENT_FLAG_NETTRANS; 
     471 } 
     472 
     473 // test if there are flags left we do not understand: 
     474 if ( flags ) { 
     475  return -1; 
     476 } 
     477 
     478 event->event = ROAR_NET2HOST32(u32[1]); 
     479 
     480 if ( event->flags & ROAR_EVENT_FLAG_PROXYEVENT ) 
     481  event->event_proxy = ROAR_NET2HOST32(u32[2]); 
     482 
     483 event->emitter     = ROAR_NET2HOST16(u16[0]); 
     484 event->target      = ROAR_NET2HOST16(u16[1]); 
     485 event->target_type = ROAR_NET2HOST16(u16[2]); 
     486 event->arg2_len    = ROAR_NET2HOST16(u16[3]); 
     487 
     488 if ( event->flags & ROAR_EVENT_FLAG_NETTRANS ) { 
     489  event->arg0 = ROAR_NET2HOST16(u16[4]); 
     490  event->arg1 = ROAR_NET2HOST16(u16[4]); 
     491  event->arg2 = blob + needed_len - event->arg2_len; 
     492 } else { 
     493  event->arg0 = -1; 
     494  event->arg1 = -1; 
     495  event->arg2 = NULL; 
     496 } 
     497 
     498 *len = needed_len; 
     499 
     500 return 0; 
     501} 
     502 
     503 
    333504//ll 
Note: See TracChangeset for help on using the changeset viewer.