Changeset 194

Show
Ignore:
Timestamp:
05/12/06 09:19:08 (16 years ago)
Author:
pieterpalmers
Message:

- code cleanup in the streaming part.
- calculate ISO connection parameters instead of user-supplying them
- SSE code improvement

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libfreebob/ChangeLog

    r192 r194  
     12006-05-12  Pieter Palmers  <pieterpalmers@users.sourceforge.net> 
     2        * src/libfreebobstreaming/*:  
     3        - Code cleanup 
     4        - Improved SSE code 
     5        - ISO connection parameters are calculated instead of being user 
     6          specified. Note: you need a new jackd backend version due to this. 
     7         
     8        * configure.ac: Version bumped to 0.8.2 
     9 
    1102006-05-06  Daniel Wagner  <wagi@monom.org> 
    211 
  • trunk/libfreebob/configure.ac

    r190 r194  
    2424m4_define(freebob_major_version, 0) 
    2525m4_define(freebob_minor_version, 8) 
    26 m4_define(freebob_micro_version, 1
     26m4_define(freebob_micro_version, 2
    2727 
    2828m4_define(freebob_version, freebob_major_version.freebob_minor_version.freebob_micro_version) 
  • trunk/libfreebob/libfreebob/freebob_streaming.h

    r185 r194  
    108108        int nb_buffers; /* the size of the frame buffer (in periods) */ 
    109109 
    110         /* RAW1394 related settings */ 
    111         int iso_buffers; 
    112         int iso_prebuffers; 
    113         int iso_irq_interval; 
    114          
    115110        /* packetizer thread options */ 
    116111        int realtime; 
     
    121116        int port; 
    122117         
    123  
    124118        /* direction map */ 
    125119        int directions; 
  • trunk/libfreebob/src/libfreebobstreaming/freebob_connections.c

    r185 r194  
    118118        connection->status.xruns = 0; 
    119119        connection->status.packets=0;    
     120 
     121#ifdef DEBUG 
     122        connection->status.total_packets_prev=0; 
     123#endif 
     124 
    120125        connection->status.dropped=0; 
    121          
     126 
    122127        // make sure the connection is polled next time 
    123128        if(connection->pfd) { // this can be called before everything is init'ed 
     
    146151        } 
    147152        raw1394_set_userdata(connection->raw_handle, (void *)connection); 
    148          
    149         // these have quite some influence on latency 
    150         connection->iso.buffers = dev->options.iso_buffers; 
    151         connection->iso.prebuffers = dev->options.iso_prebuffers; 
    152         connection->iso.irq_interval = dev->options.iso_irq_interval; 
    153153         
    154154        connection->iso.speed = RAW1394_ISO_SPEED_400; 
  • trunk/libfreebob/src/libfreebobstreaming/freebob_connections.h

    r185 r194  
    152152        int irq_interval; 
    153153        int startcycle; 
    154          
     154        enum raw1394_iso_dma_recv_mode receive_mode; 
     155 
    155156        int iso_channel; 
    156157        int do_disconnect; 
    157158        int bandwidth; 
     159 
     160        int packets_per_period; 
     161        int max_packet_size; // tailored to result in optimal IRQ timing 
     162        int packet_size; // expected packet size 
    158163         
    159164        int hostplug; 
     
    165170        int packets; 
    166171        int events; 
    167         //int total_packets; 
    168         int total_packets_prev; 
    169172        int total_events; 
    170173 
     
    179182        int dropped; 
    180183         
     184         
     185#ifdef DEBUG 
    181186        int fdf; 
    182          
     187        int total_packets_prev; 
    183188        int last_cycle;  
     189#endif 
    184190 
    185191        int packet_info_table_size; 
  • trunk/libfreebob/src/libfreebobstreaming/freebob_streaming.c

    r190 r194  
    101101        printMessage("  Period Size              : %d\n",options.period_size); 
    102102        printMessage("  Nb Buffers               : %d\n",options.nb_buffers); 
    103         printMessage("  RAW1394 ISO Buffers      : %d\n",options.iso_buffers); 
    104         printMessage("  RAW1394 ISO Prebuffers   : %d\n",options.iso_prebuffers); 
    105         printMessage("  RAW1394 ISO IRQ Interval : %d\n",options.iso_irq_interval); 
    106103        printMessage("  Directions               : %X\n",options.directions); 
    107104         
     
    561558                err=0; 
    562559                freebob_connection_t *connection= &(dev->connections[i]); 
    563                  
     560 
     561                int fdf, syt_interval; 
     562 
     563                int samplerate=dev->options.sample_rate; 
     564 
     565                switch (samplerate) { 
     566                case 32000: 
     567                        syt_interval = 8; 
     568                        fdf = IEC61883_FDF_SFC_32KHZ; 
     569                        break; 
     570                case 44100: 
     571                        syt_interval = 8; 
     572                        fdf = IEC61883_FDF_SFC_44K1HZ; 
     573                        break; 
     574                default: 
     575                case 48000: 
     576                        syt_interval = 8; 
     577                        fdf = IEC61883_FDF_SFC_48KHZ; 
     578                        break; 
     579                case 88200: 
     580                        syt_interval = 16; 
     581                        fdf = IEC61883_FDF_SFC_88K2HZ; 
     582                        break; 
     583                case 96000: 
     584                        syt_interval = 16; 
     585                        fdf = IEC61883_FDF_SFC_96KHZ; 
     586                        break; 
     587                case 176400: 
     588                        syt_interval = 32; 
     589                        fdf = IEC61883_FDF_SFC_176K4HZ; 
     590                        break; 
     591                case 192000: 
     592                        syt_interval = 32; 
     593                        fdf = IEC61883_FDF_SFC_192KHZ; 
     594                        break; 
     595                } 
     596                 
     597                if(dev->options.period_size < syt_interval) { 
     598                        printError("Period size (%d) too small! Samplerate %d requires period >= %d\n", 
     599                                   dev->options.period_size, samplerate, syt_interval); 
     600                        return -1; 
     601                } 
     602                connection->iso.packets_per_period = dev->options.period_size/syt_interval; 
     603 
    564604                //connection->plug=0; 
    565605                connection->iso.hostplug=-1; 
     
    596636                                 
    597637                        } 
    598                          
    599                         // this moved to iso_connection_start in order to work around a raw1394 bug 
    600 #if 0 
    601                         if (connection->spec.is_master) { //master connection 
    602                                 debugPrint(DEBUG_LEVEL_STARTUP, "Init ISO master receive handler on channel %d...\n",connection->iso.iso_channel); 
    603                                 debugPrint(DEBUG_LEVEL_STARTUP, "   (BUFFER=%d,PACKET_MAX=%d,IRQ=%d)...\n",connection->iso.buffers,AMDTP_MAX_PACKET_SIZE, connection->iso.irq_interval); 
    604                                 raw1394_iso_recv_init( 
    605                                         connection->raw_handle,  
    606                                         iso_master_receive_handler,  
    607                                         connection->iso.buffers,  
    608                                         AMDTP_MAX_PACKET_SIZE,  
    609                                         connection->iso.iso_channel,  
    610                                         RAW1394_DMA_BUFFERFILL,  
    611                                         connection->iso.irq_interval); 
    612                                                                                  
    613                                 dev->sync_master_connection=connection; 
    614                                 connection->status.master=NULL; 
    615                                  
     638 
     639                        // setup the optimal parameters for the raw1394 ISO buffering 
     640                        connection->iso.packets_per_period=dev->options.period_size/syt_interval; 
     641                        // hardware interrupts occur when one DMA block is full, and the size of one DMA 
     642                        // block = PAGE_SIZE. Setting the max_packet_size makes sure that the HW irq  
     643                        // occurs at a period boundary (optimal CPU use) 
     644                        // note: try and use 2 interrupts per period for better latency. 
     645                        connection->iso.max_packet_size=getpagesize() / connection->iso.packets_per_period * 2; 
     646                        connection->iso.irq_interval=connection->iso.packets_per_period/2; 
     647 
     648                        connection->iso.packet_size=4 * (2 + syt_interval * connection->spec.dimension); 
     649 
     650                        if (connection->iso.max_packet_size < connection->iso.packet_size) { 
     651                                connection->iso.max_packet_size=connection->iso.packet_size; 
     652                        } 
     653 
     654                        /* the receive buffer size doesn't matter for the latency, 
     655                           but it has a minimal value in order for libraw to operate correctly (300) */ 
     656                        connection->iso.buffers=400; 
     657 
     658                        // this is a hack 
     659                        if(dev->options.period_size < 128) { 
     660                                connection->iso.receive_mode=RAW1394_DMA_PACKET_PER_BUFFER; 
    616661                        } else { 
    617                                 //slave receive connection 
    618                                 debugPrint(DEBUG_LEVEL_STARTUP, "Init ISO slave receive handler on channel %d...\n",connection->iso.iso_channel); 
    619                                 debugPrint(DEBUG_LEVEL_STARTUP, "   (BUFFER=%d,PACKET_MAX=%d,IRQ=%d)...\n", connection->iso.buffers, AMDTP_MAX_PACKET_SIZE, connection->iso.irq_interval); 
    620                                 raw1394_iso_recv_init(   
    621                                         connection->raw_handle,  
    622                                         iso_slave_receive_handler,  
    623                                         connection->iso.buffers,  
    624                                         AMDTP_MAX_PACKET_SIZE,  
    625                                         connection->iso.iso_channel,  
    626                                         RAW1394_DMA_BUFFERFILL,  
    627                                         connection->iso.irq_interval); 
     662                                connection->iso.receive_mode=RAW1394_DMA_BUFFERFILL; 
    628663                        } 
    629 #endif                   
     664 
    630665                break; 
    631666                case FREEBOB_PLAYBACK: 
     
    651686                                connection->status.master=NULL; 
    652687                        } 
    653                          
    654                         // this moved to iso_connection_start in order to work around a raw1394 bug 
    655 #if 0 
    656                         if (connection->spec.is_master) { // master connection 
    657                                 debugPrint(DEBUG_LEVEL_STARTUP, "Init ISO master transmit handler on channel %d...\n",connection->iso.iso_channel); 
    658                                 debugPrint(DEBUG_LEVEL_STARTUP, "   other mode (BUFFER=%d,PACKET_MAX=%d,IRQ=%d)...\n",connection->iso.buffers,AMDTP_MAX_PACKET_SIZE, connection->iso.irq_interval); 
    659                                  
    660                                 raw1394_iso_xmit_init( 
    661                                         connection->raw_handle,  
    662                                         iso_master_transmit_handler,  
    663                                         connection->iso.buffers, 
    664                                         AMDTP_MAX_PACKET_SIZE,  
    665                                         connection->iso.iso_channel,  
    666                                         RAW1394_ISO_SPEED_400,  
    667                                         connection->iso.irq_interval); 
    668  
    669                                 dev->sync_master_connection=connection; 
    670                                 connection->status.master=NULL; 
    671                          
    672                         } else { 
    673                          
    674                                 debugPrint(DEBUG_LEVEL_STARTUP, "Init ISO slave transmit handler on channel %d...\n",connection->iso.iso_channel); 
    675                                 debugPrint(DEBUG_LEVEL_STARTUP, "   (BUFFER=%d,PACKET_MAX=%d,IRQ=%d)...\n",connection->iso.buffers,AMDTP_MAX_PACKET_SIZE, connection->iso.irq_interval); 
    676                                 raw1394_iso_xmit_init( 
    677                                         connection->raw_handle,  
    678                                         iso_slave_transmit_handler,  
    679                                         connection->iso.buffers, 
    680                                         AMDTP_MAX_PACKET_SIZE,  
    681                                         connection->iso.iso_channel,  
    682                                         RAW1394_ISO_SPEED_400,  
    683                                         connection->iso.irq_interval); 
    684                         } 
    685 #endif                   
    686                         int fdf, syt_interval; 
    687 // FIXME:                
    688                         int samplerate=dev->options.sample_rate; 
    689 //                      int samplerate=connection->spec.samplerate; 
    690  
    691                         switch (samplerate) { 
    692                         case 32000: 
    693                                 syt_interval = 8; 
    694                                 fdf = IEC61883_FDF_SFC_32KHZ; 
    695                                 break; 
    696                         case 44100: 
    697                                 syt_interval = 8; 
    698                                 fdf = IEC61883_FDF_SFC_44K1HZ; 
    699                                 break; 
    700                         default: 
    701                         case 48000: 
    702                                 syt_interval = 8; 
    703                                 fdf = IEC61883_FDF_SFC_48KHZ; 
    704                                 break; 
    705                         case 88200: 
    706                                 syt_interval = 16; 
    707                                 fdf = IEC61883_FDF_SFC_88K2HZ; 
    708                                 break; 
    709                         case 96000: 
    710                                 syt_interval = 16; 
    711                                 fdf = IEC61883_FDF_SFC_96KHZ; 
    712                                 break; 
    713                         case 176400: 
    714                                 syt_interval = 32; 
    715                                 fdf = IEC61883_FDF_SFC_176K4HZ; 
    716                                 break; 
    717                         case 192000: 
    718                                 syt_interval = 32; 
    719                                 fdf = IEC61883_FDF_SFC_192KHZ; 
    720                                 break; 
    721                         } 
    722                                                                  
     688 
    723689                        iec61883_cip_init ( 
    724690                                &connection->status.cip,  
     
    733699                                IEC61883_MODE_BLOCKING_EMPTY); 
    734700 
     701 
     702                        // setup the optimal parameters for the raw1394 ISO buffering 
     703                        connection->iso.packets_per_period=dev->options.period_size/syt_interval; 
     704                        // hardware interrupts occur when one DMA block is full, and the size of one DMA 
     705                        // block = PAGE_SIZE. Setting the max_packet_size makes sure that the HW irq is  
     706                        // occurs at a period boundary (optimal CPU use) 
     707                        // note: try and use 2 interrupts per period for better latency. 
     708                        connection->iso.max_packet_size=getpagesize() / connection->iso.packets_per_period * 2; 
     709                        connection->iso.irq_interval=connection->iso.packets_per_period / 2; 
     710 
     711                        connection->iso.packet_size=4 * (2 + syt_interval * connection->spec.dimension); 
     712 
     713                        if (connection->iso.max_packet_size < connection->iso.packet_size) { 
     714                                connection->iso.max_packet_size=connection->iso.packet_size; 
     715                        } 
     716 
     717                        /* the transmit buffer size should be as low as possible for latency.  
     718                        */ 
     719                        connection->iso.buffers=connection->iso.packets_per_period; 
     720                        if (connection->iso.buffers<10) connection->iso.buffers=10; 
     721 
    735722                break; 
    736723                } 
     
    741728                        while(i>=0) { 
    742729                                connection= &(dev->connections[i]); 
    743                  
    744                                 // not nescessary anymore since it moved to the iso_start function 
    745 /*                              debugPrint(DEBUG_LEVEL_STARTUP, "Shutdown connection %d on channel %d ...\n", i, connection->iso.iso_channel); 
    746                                  
    747                                 raw1394_iso_shutdown(connection->raw_handle); 
    748 */ 
    749730                 
    750731                                if (connection->iso.do_disconnect) { 
     
    843824        debugPrint(DEBUG_LEVEL_STARTUP,"Armed...\n"); 
    844825         
    845         //freebob_streaming_start_iso(dev); 
    846          
    847826        freebob_streaming_start_thread(dev); 
    848827 
     
    857836        freebob_streaming_stop_thread(dev); 
    858837         
    859         //freebob_streaming_stop_iso(dev); 
    860  
    861838        // stop ISO xmit/receive 
    862839        for(i=0; i < dev->nb_connections; i++) { 
    863840                freebob_connection_t *connection= &(dev->connections[i]); 
    864  
    865                 // this moved to iso_connection_stop in order to work around a raw1394 bug 
    866 #if 0 
    867                 debugPrint(DEBUG_LEVEL_STARTUP, "Shutdown connection %d on channel %d ...\n", i, connection->iso.iso_channel); 
    868                  
    869                 raw1394_iso_shutdown(connection->raw_handle); 
    870 #endif 
    871841 
    872842                if (connection->iso.do_disconnect) { 
     
    14491419                connection->status.dropped=0;            
    14501420                if (connection->spec.is_master) { //master connection 
    1451                         debugPrint(DEBUG_LEVEL_STARTUP, "Init ISO master receive handler on channel %d...\n",connection->iso.iso_channel); 
    1452                         debugPrint(DEBUG_LEVEL_STARTUP, "   (BUFFER=%d,PACKET_MAX=%d,IRQ=%d)...\n",connection->iso.buffers,AMDTP_MAX_PACKET_SIZE, connection->iso.irq_interval); 
     1421 
     1422                        debugPrint(DEBUG_LEVEL_STARTUP,  
     1423                                "Init ISO master receive handler on channel %d...\n", 
     1424                                connection->iso.iso_channel); 
     1425 
     1426                        debugPrint(DEBUG_LEVEL_STARTUP,  
     1427                                "   (%s, BUFFERS=%d, PACKET_SIZE=%d, PACKET_MAX=%d, IRQ=%d, %d PKT/PERIOD)...\n", 
     1428                                (connection->iso.receive_mode==RAW1394_DMA_PACKET_PER_BUFFER ? "PACKET_PER_BUFFER" : "BUFFERFILL"), 
     1429                                connection->iso.buffers,  
     1430                                connection->iso.packet_size, 
     1431                                connection->iso.max_packet_size, 
     1432                                connection->iso.irq_interval, 
     1433                                connection->iso.packets_per_period); 
     1434 
    14531435                        raw1394_iso_recv_init( 
    14541436                                        connection->raw_handle,  
    14551437                                        iso_master_receive_handler,  
    1456                                         /* the receive buffer size doesn't matter for the latency,  
    1457                                            but it has a minimal value in order for libraw to operate correctly (300)  
    1458                                         */ 
    1459                                         400, 
    1460                                         AMDTP_MAX_PACKET_SIZE,  
     1438                                        connection->iso.buffers, 
     1439                                        connection->iso.max_packet_size,  
    14611440                                        connection->iso.iso_channel,  
    1462 //                                      RAW1394_DMA_BUFFERFILL,  
    1463                                         /* Packet per buffer enables low latency */ 
    1464                                         RAW1394_DMA_PACKET_PER_BUFFER,  
     1441                                        connection->iso.receive_mode, // RAW1394_DMA_BUFFERFILL,  
    14651442                                        connection->iso.irq_interval); 
    14661443 
    14671444                } else { 
    1468                                 //slave receive connection 
    1469                         debugPrint(DEBUG_LEVEL_STARTUP, "Init ISO slave receive handler on channel %d...\n",connection->iso.iso_channel); 
    1470                         debugPrint(DEBUG_LEVEL_STARTUP, "   (BUFFER=%d,PACKET_MAX=%d,IRQ=%d)...\n", connection->iso.buffers, AMDTP_MAX_PACKET_SIZE, connection->iso.irq_interval); 
     1445                        //slave receive connection 
     1446                        debugPrint(DEBUG_LEVEL_STARTUP,  
     1447                                "Init ISO slave receive handler on channel %d...\n", 
     1448                                connection->iso.iso_channel); 
     1449 
     1450                        debugPrint(DEBUG_LEVEL_STARTUP,  
     1451                                "   (%s, BUFFERS=%d, PACKET_SIZE=%d, PACKET_MAX=%d, IRQ=%d, %d PKT/PERIOD)...\n", 
     1452                                (connection->iso.receive_mode==RAW1394_DMA_PACKET_PER_BUFFER ? "PACKET_PER_BUFFER" : "BUFFERFILL"),                             connection->iso.buffers,  
     1453                                connection->iso.packet_size, 
     1454                                connection->iso.max_packet_size, 
     1455                                connection->iso.irq_interval, 
     1456                                connection->iso.packets_per_period); 
     1457 
    14711458                        raw1394_iso_recv_init(   
    14721459                                        connection->raw_handle,  
    14731460                                        iso_slave_receive_handler,  
    1474                                         /* the receive buffer size doesn't matter for the latency,  
    1475                                            but it has a minimal value in order for libraw to operate correctly (300)  
    1476                                         */ 
    1477                                         400, 
    1478                                         AMDTP_MAX_PACKET_SIZE,  
     1461                                        connection->iso.buffers, 
     1462                                        connection->iso.max_packet_size,  
    14791463                                        connection->iso.iso_channel,  
    1480 //                                      RAW1394_DMA_BUFFERFILL,  
    1481                                         /* Packet per buffer enables low latency */ 
    1482                                         RAW1394_DMA_PACKET_PER_BUFFER,  
     1464                                        connection->iso.receive_mode, // RAW1394_DMA_BUFFERFILL,  
    14831465                                        connection->iso.irq_interval); 
    14841466                } 
    14851467                 
    1486                 debugPrint(DEBUG_LEVEL_STARTUP, "Start ISO receive for connection on channel %d at cycle %d...\n",  connection->iso.iso_channel, connection->iso.startcycle); 
     1468                debugPrint(DEBUG_LEVEL_STARTUP,  
     1469                        "Start ISO receive for connection on channel %d at cycle %d...\n", 
     1470                          connection->iso.iso_channel, connection->iso.startcycle); 
    14871471                         
    14881472                err = raw1394_iso_recv_start( 
     
    15021486                 
    15031487                if (connection->spec.is_master) { // master connection 
    1504                         debugPrint(DEBUG_LEVEL_STARTUP, "Init ISO master transmit handler on channel %d...\n",connection->iso.iso_channel); 
    1505                         debugPrint(DEBUG_LEVEL_STARTUP, "   other mode (BUFFER=%d,PACKET_MAX=%d,IRQ=%d)...\n",connection->iso.buffers,AMDTP_MAX_PACKET_SIZE, connection->iso.irq_interval); 
     1488                        debugPrint(DEBUG_LEVEL_STARTUP,  
     1489                                "Init ISO master transmit handler on channel %d...\n", 
     1490                                connection->iso.iso_channel); 
     1491 
     1492                        debugPrint(DEBUG_LEVEL_STARTUP,  
     1493                                "   (BUFFERS=%d, PACKET_SIZE=%d, PACKET_MAX=%d, IRQ=%d, %d PKT/PERIOD)...\n", 
     1494                                connection->iso.buffers,  
     1495                                connection->iso.packet_size, 
     1496                                connection->iso.max_packet_size, 
     1497                                connection->iso.irq_interval, 
     1498                                connection->iso.packets_per_period); 
     1499 
    15061500                                 
    15071501                        raw1394_iso_xmit_init( 
     
    15091503                                        iso_master_transmit_handler,  
    15101504                                        connection->iso.buffers, 
    1511                                         AMDTP_MAX_PACKET_SIZE,  
     1505                                        connection->iso.max_packet_size,  
    15121506                                        connection->iso.iso_channel,  
    15131507                                        RAW1394_ISO_SPEED_400,  
     
    15151509                } else { 
    15161510                         
    1517                         debugPrint(DEBUG_LEVEL_STARTUP, "Init ISO slave transmit handler on channel %d...\n",connection->iso.iso_channel); 
    1518                         debugPrint(DEBUG_LEVEL_STARTUP, "   (BUFFER=%d,PACKET_MAX=%d,IRQ=%d)...\n",connection->iso.buffers,AMDTP_MAX_PACKET_SIZE, connection->iso.irq_interval); 
     1511                        debugPrint(DEBUG_LEVEL_STARTUP,  
     1512                                "Init ISO slave transmit handler on channel %d...\n", 
     1513                                connection->iso.iso_channel); 
     1514 
     1515                        debugPrint(DEBUG_LEVEL_STARTUP,  
     1516                                "   (BUFFERS=%d, PACKET_SIZE=%d, PACKET_MAX=%d, IRQ=%d, %d PKT/PERIOD)...\n", 
     1517                                connection->iso.buffers,  
     1518                                connection->iso.packet_size, 
     1519                                connection->iso.max_packet_size, 
     1520                                connection->iso.irq_interval, 
     1521                                connection->iso.packets_per_period); 
     1522 
    15191523                        raw1394_iso_xmit_init( 
    15201524                                        connection->raw_handle,  
    15211525                                        iso_slave_transmit_handler,  
    15221526                                        connection->iso.buffers, 
    1523                                         AMDTP_MAX_PACKET_SIZE,  
     1527                                        connection->iso.max_packet_size,  
    15241528                                        connection->iso.iso_channel,  
    15251529                                        RAW1394_ISO_SPEED_400,  
    1526                                         connection->iso.irq_interval); 
    1527                 }                
    1528                 debugPrint(DEBUG_LEVEL_STARTUP, "Start ISO transmit for connection on channel %d at cycle %d\n", connection->iso.iso_channel, connection->iso.startcycle); 
     1530                                        connection->iso.irq_interval);   
     1531 
     1532                } 
     1533         
     1534                debugPrint(DEBUG_LEVEL_STARTUP,  
     1535                        "Start ISO transmit for connection on channel %d at cycle %d\n", 
     1536                        connection->iso.iso_channel, connection->iso.startcycle); 
    15291537                         
    15301538                err=raw1394_iso_xmit_start( 
    1531                                connection->raw_handle,  
    1532                 connection->iso.startcycle,  
    1533                 connection->iso.prebuffers); 
     1539                        connection->raw_handle,  
     1540                       connection->iso.startcycle,  
     1541                       connection->iso.prebuffers); 
    15341542 
    15351543                if (err) { 
     
    17161724        debugPrint(DEBUG_LEVEL_STARTUP, "Go Go Go!!!\n"); 
    17171725         
    1718         //sem_post(&dev->packetizer.transfer_ack); 
    17191726#define POLL_BASED       
    17201727#ifdef POLL_BASED  
    17211728        while (dev->packetizer.run && !underrun_detected) { 
    1722                 //sem_wait(&dev->packetizer.transfer_ack); 
    17231729                 
    17241730                freebob_streaming_period_reset(dev); 
     
    17541760                                } 
    17551761                                 
    1756 //                              if(dev->pfds[i].revents & (POLLIN | POLLPRI)) { 
    17571762                                if(dev->pfds[i].revents & (POLLIN)) { 
    17581763                                        // FIXME: this can segfault  
     
    17881793                if(underrun_detected) { 
    17891794                        dev->xrun_detected=TRUE; 
    1790                         //underrun_detected=0; 
    17911795                } 
    17921796 
    17931797#else 
    17941798        while (dev->packetizer.run && !underrun_detected) { 
    1795                 //sem_wait(&dev->packetizer.transfer_ack); 
    17961799                 
    17971800                freebob_streaming_period_reset(dev); 
     
    18361839                                connection = &(dev->connections[c]); 
    18371840                                 
    1838                                 // skip the sync master and the connections that are finished 
    1839                                 //if ((connection == dev->sync_master_connection) || (connection->status.frames_left <= 0)) 
    1840                                          
    18411841                                if ((connection == dev->sync_master_connection)) 
    18421842                                                continue; 
     
    18651865                if(underrun_detected) { 
    18661866                        dev->xrun_detected=TRUE; 
    1867                                 //underrun_detected=0; 
    18681867                } 
    18691868         
     
    18831882 
    18841883#ifdef DEBUG 
    1885                 // update the packet counter 
    18861884                if((dev->sync_master_connection->status.packets - dev->sync_master_connection->status.total_packets_prev) > 1024*2) { 
    1887 //              if(1) { 
    18881885                        unsigned int i; 
    18891886                        debugPrintShort(DEBUG_LEVEL_PACKETCOUNTER,"\r -> "); 
     
    18931890                                assert(connection); 
    18941891                                 
    1895                                 /* Debug info format: 
    1896                                 * [direction, packetcount, bufferfill, packetdrop 
    1897                                 */ 
    18981892                                debugPrintShort(DEBUG_LEVEL_PACKETCOUNTER,"[%s, %02d, %10d, %04d, %4d, (R: %04d)]",  
    18991893                                        (connection->spec.direction==FREEBOB_CAPTURE ? "C" : "P"), 
     
    19501944} 
    19511945 
    1952 int freebob_streaming_decode_midi(freebob_connection_t *connection, 
     1946inline int freebob_streaming_decode_midi(freebob_connection_t *connection, 
    19531947                                                                  quadlet_t* events,  
    19541948                                                                  unsigned int nsamples, 
     
    19841978                        written=0; 
    19851979                         
    1986 //                      debugPrint(DEBUG_LEVEL_PACKETCOUNTER, "Stream %d,%d,%d is midi, dbc=%d  [",s,stream->spec.location,stream->spec.position,dbc); 
    1987                                                  
    1988 //                      for(j = (dbc%8)+stream->spec.location-1; j < nsamples; j += 8) { 
    19891980                        for(j = (dbc & 0x07)+stream->spec.location-1; j < nsamples; j += 8) { 
    19901981                                target_event=(quadlet_t *)(events + ((j * connection->spec.dimension) + stream->spec.position)); 
     
    19921983                                if(IEC61883_AM824_GET_LABEL(sample_int) != IEC61883_AM824_LABEL_MIDI_NO_DATA) { 
    19931984                                        *(buffer)=(sample_int >> 16); 
    1994 //                                      debugPrintShort(DEBUG_LEVEL_PACKETCOUNTER, "%08X-%08X-%d ",*target_event,*buffer,((j * connection->spec.dimension) + stream->spec.position)); 
    19951985                                        buffer++; 
    19961986                                        written++; 
     
    20021992                                printMessage("MIDI OUT bytes lost (%d/%d)",written_to_rb,written); 
    20031993                        } 
    2004 //                      debugPrintShort(DEBUG_LEVEL_PACKETCOUNTER, "]\n"); 
    2005                          
    2006                          
    2007                         /*                                               
    2008                         for(j = 0; j < nsamples; j += 1) { 
    2009                                 target_event=(quadlet_t *)(events + j); 
    2010                                 quadlet_t sample_int=ntohl(*target_event); 
    2011                                 *(buffer)=sample_int; 
    2012                                 buffer++; 
    2013                                 written++; 
    2014  
    2015                         } 
    2016                         written=freebob_ringbuffer_write(stream->buffer, (char *)(stream->user_buffer), written*sizeof(quadlet_t))/sizeof(quadlet_t); 
    2017                         */ 
    20181994                } 
    20191995        } 
     
    20272003 */ 
    20282004 
    2029 int freebob_streaming_encode_midi(freebob_connection_t *connection, 
     2005inline int freebob_streaming_encode_midi(freebob_connection_t *connection, 
    20302006                                                                quadlet_t* events,  
    20312007                                                                unsigned int nsamples, 
     
    20812057                                stream->midi_counter--; 
    20822058                        } 
    2083                         /*                       
    2084                         for(j=0; (j < nsamples); j++) { 
    2085                                 target_event=(quadlet_t *)(events + ((j * connection->spec.dimension) + stream->spec.position)); 
    2086                                  
    2087                                 hexDumpQuadlets( target_event,1); 
    2088                         } 
    2089                         */ 
    2090                          
    20912059                } 
    20922060        } 
     
    21062074        unsigned int dropped) 
    21072075{ 
    2108     enum raw1394_iso_disposition retval=RAW1394_ISO_OK; 
    2109 //      static quadlet_t cntr=0; 
    2110          
    2111 //      int xrun=0; 
     2076        enum raw1394_iso_disposition retval=RAW1394_ISO_OK; 
    21122077 
    21132078        freebob_connection_t *connection=(freebob_connection_t *) raw1394_get_userdata (handle); 
     
    21182083         
    21192084        // FIXME: dropped packets are very bad when transmitting and the other side is sync'ing on that! 
    2120         //connection->status.packets+=dropped; 
    21212085        connection->status.dropped+=dropped; 
    2122          
     2086 
     2087#ifdef DEBUG     
    21232088        connection->status.last_cycle=cycle; 
     2089#endif 
    21242090 
    21252091        if((packet->fmt == 0x10) && (packet->fdf != 0xFF) && (packet->dbs>0) && (length>=2*sizeof(quadlet_t))) { 
     
    21292095 
    21302096                assert(connection->spec.dimension == packet->dbs); 
    2131                  
    2132 //              if(nevents>2) { 
    2133 //                      quadlet_t *t=(quadlet_t *)(data+8); 
    2134 //                      t+=2; 
    2135 //                       
    2136 //                      t++; 
    2137 //                      *t=0x40000000 | ((cntr) & 0xFFFFFF); 
    2138 //                      t++; 
    2139 //                      *t=0x40000000 | ((cntr++) & 0xFFFFFF); 
    2140 //              } 
    21412097                 
    21422098                if (freebob_ringbuffer_write( 
     
    21592115                // keep track of the total amount of events received 
    21602116                connection->status.events+=nevents; 
    2161                  
     2117 
     2118#ifdef DEBUG     
    21622119                connection->status.fdf=packet->fdf; 
    2163                  
    2164                 connection->status.last_timestamp.cycle=cycle; 
    2165                 connection->status.last_timestamp.syt=packet->syt; 
    2166                  
    2167                 freebob_streaming_append_master_timestamp(connection->parent, &connection->status.last_timestamp); 
     2120#endif 
     2121                 
    21682122        } else { 
    21692123                // discard packet 
     
    21892143                return RAW1394_ISO_DEFER; 
    21902144        } 
    2191 //      if( (!(connection->status.packets % 2))) { 
    2192         if( (!(connection->status.packets & 0x01))) { 
    2193                 return RAW1394_ISO_DEFER; 
    2194         } 
     2145 
    21952146        return retval; 
    21962147} 
     
    22112162        /* TODO: implement correct SYT behaviour */ 
    22122163                 
    2213 //      int xrun=0; 
    2214  
    22152164        freebob_connection_t *connection=(freebob_connection_t *) raw1394_get_userdata (handle); 
    22162165        assert(connection); 
     
    22232172        connection->status.dropped+=dropped; 
    22242173 
     2174#ifdef DEBUG     
    22252175        connection->status.last_cycle=cycle; 
     2176#endif 
    22262177 
    22272178        if((packet->fmt == 0x10) && (packet->fdf != 0xFF) && (packet->dbs>0) && (length>=2*sizeof(quadlet_t))) { 
    22282179                unsigned int nevents=((length / sizeof (quadlet_t)) - 2)/packet->dbs; 
     2180 
     2181#ifdef DEBUG     
    22292182                connection->status.fdf=packet->fdf; 
     2183#endif 
    22302184                 
    22312185                // add the data payload to the ringbuffer 
     
    22612215        if(packet->dbs) { 
    22622216                debugPrintWithTimeStamp(DEBUG_LEVEL_HANDLERS_LOWLEVEL,  
    2263                                                                 "SLAVE RCV: CH = %d, FDF = %X. SYT = %6d, DBS = %3d, DBC = %3d, FMT = %3d, LEN = %4d (%2d), DROPPED = %6d\n",  
    2264                                                                 channel, packet->fdf,packet->syt,packet->dbs,packet->dbc,packet->fmt, length, 
    2265                                                                 ((length / sizeof (quadlet_t)) - 2)/packet->dbs, dropped); 
     2217                        "SLAVE RCV: CH = %d, FDF = %X. SYT = %6d, DBS = %3d, DBC = %3d, FMT = %3d, LEN = %4d (%2d), DROPPED = %6d\n",  
     2218                        channel, packet->fdf, 
     2219                        packet->syt, 
     2220                        packet->dbs, 
     2221                        packet->dbc, 
     2222                        packet->fmt,  
     2223                        length, 
     2224                        ((length / sizeof (quadlet_t)) - 2)/packet->dbs, dropped); 
    22662225        } 
    22672226                 
     
    22712230                return RAW1394_ISO_DEFER; 
    22722231        } 
    2273 //      if( (!(connection->status.packets % 2))) { 
    2274         if( (!(connection->status.packets & 0x01))) { 
    2275                 return RAW1394_ISO_DEFER; 
    2276         } 
     2232 
    22772233        return retval; 
    22782234} 
     
    23052261        // construct the packet cip 
    23062262        int nevents = iec61883_cip_fill_header (handle, &connection->status.cip, packet); 
    2307 //      int xrun=0; 
    23082263        int nsamples=0; 
    23092264        int bytes_read; 
    23102265         
    2311         freebob_timestamp_t tstamp; 
    2312          
    2313 //      unsigned int syt; 
    2314  
     2266#ifdef DEBUG     
    23152267        connection->status.last_cycle=cycle; 
    2316          
    2317         enum raw1394_iso_disposition retval = RAW1394_ISO_OK; 
    2318          
    2319         int i; 
    2320         // if packets are dropped, also drop the same amount of timestamps from the ringbuffer 
    2321         for (i=0;i<dropped;i++) { 
    2322                 freebob_ringbuffer_read(connection->timestamp_buffer,(char *)&tstamp,sizeof(freebob_timestamp_t)); 
    2323         } 
    2324                  
    2325 // debug 
     2268 
    23262269        if(packet->fdf != 0xFF) { 
    23272270                connection->status.fdf=packet->fdf; 
    23282271        } 
     2272#endif 
     2273 
     2274        enum raw1394_iso_disposition retval = RAW1394_ISO_OK; 
     2275 
     2276 
    23292277 
    23302278        if (nevents > 0) { 
     
    23412289         
    23422290        // dropped packets are very bad when transmitting and the other side is sync'ing on that! 
    2343         //connection->status.packets+=dropped; 
    23442291        connection->status.dropped += dropped; 
    23452292                 
    23462293        if (nsamples > 0) { 
    2347                  
    2348                 if(freebob_ringbuffer_read(connection->timestamp_buffer,(char *)&tstamp,sizeof(freebob_timestamp_t))) { 
    2349                         packet->syt=tstamp.syt+connection->total_delay; 
    2350                 } 
    23512294 
    23522295                assert(connection->spec.dimension == packet->dbs); 
     
    23682311        } 
    23692312         
    2370 //      if (xrun) { 
    2371 //              printError("SLAVE XMT: Buffer underrun!\n"); 
    2372 //              connection->status.xruns++; 
    2373 //              retval=RAW1394_ISO_DEFER; 
    2374 //              nsamples=0; 
    2375 //      } 
    2376  
    23772313        *length = nsamples * connection->spec.dimension * sizeof (quadlet_t) + 8; 
    23782314        *tag = IEC61883_TAG_WITH_CIP; 
     
    23942330                                                                nevents, nsamples); 
    23952331        } 
    2396         // TODO: the -100 should be derrived from the buffer size 
     2332 
    23972333        if((connection->status.frames_left<=0)) { 
    23982334                connection->pfd->events=0; 
    23992335                return RAW1394_ISO_DEFER; 
    24002336        } 
    2401 //      if( (!(connection->status.packets % 2))) { 
    2402         if( (!(connection->status.packets & 0x01))) { 
    2403                 return RAW1394_ISO_DEFER; 
    2404         } 
     2337 
    24052338        return retval; 
    24062339 
     
    24272360         
    24282361        int nevents = iec61883_cip_fill_header (handle, &connection->status.cip, packet); 
    2429 //      int xrun=0; 
    24302362        int nsamples=0; 
    24312363        int bytes_read; 
    2432          
    2433         freebob_timestamp_t tstamp; 
    2434          
    2435 //      unsigned int syt; 
     2364 
     2365#ifdef DEBUG     
    24362366        connection->status.last_cycle=cycle; 
    2437          
    2438         enum raw1394_iso_disposition retval = RAW1394_ISO_OK; 
    2439          
    2440         int i; 
    2441         // if packets are dropped, also drop the same amount of timestamps from the ringbuffer 
    2442         for (i=0;i<dropped;i++) { 
    2443                 freebob_ringbuffer_read(connection->timestamp_buffer,(char *)&tstamp,sizeof(freebob_timestamp_t)); 
    2444         } 
    2445          
    2446 // debug 
     2367 
    24472368        if(packet->fdf != 0xFF) { 
    24482369                connection->status.fdf=packet->fdf; 
    24492370        } 
     2371#endif 
     2372 
     2373        enum raw1394_iso_disposition retval = RAW1394_ISO_OK; 
     2374 
    24502375 
    24512376        if (nevents > 0) { 
     
    24672392        if (nsamples > 0) { 
    24682393                int bytes_to_read=nsamples*sizeof(quadlet_t)*connection->spec.dimension; 
    2469  
    2470                 if(freebob_ringbuffer_read(connection->timestamp_buffer,(char *)&tstamp,sizeof(freebob_timestamp_t))) { 
    2471                         packet->syt=tstamp.syt+connection->total_delay; 
    2472                 } 
    24732394 
    24742395                assert(connection->spec.dimension == packet->dbs); 
     
    25082429                        freebob_streaming_encode_midi(connection,(quadlet_t *)(data+8), nevents, packet->dbc); 
    25092430                } 
    2510 //              hexDumpQuadlets( data,nsamples*connection->spec.dimension+2); 
    25112431        } 
    25122432         
     
    25312451        } 
    25322452 
    2533 /*    if((connection->status.frames_left<=0)) { 
     2453      if((connection->status.frames_left<=0)) { 
    25342454                connection->pfd->events=0; 
    25352455                return RAW1394_ISO_DEFER; 
    25362456        } 
    2537 */ 
    2538 /*      if( (!(connection->status.packets % 2))) { 
    2539                 return RAW1394_ISO_DEFER; 
    2540         }*/ 
     2457 
    25412458        return retval; 
    25422459 
     
    25852502                case freebob_buffer_type_per_stream: 
    25862503                default: 
    2587 //                      assert(nsamples < dev->options.period_size); 
    2588                          
    25892504                        // use the preallocated buffer (at init time) 
    25902505                        buffer=((freebob_sample_t *)(stream->user_buffer))+stream->user_buffer_position; 
     
    26182533                                for(j = 0; j < nsamples; j += 1) { // decode max nsamples 
    26192534                                        *(buffer)=(ntohl((*target_event) ) & 0x00FFFFFF); 
    2620                 //                      fprintf(stderr,"[%03d, %02d: %08p %08X %08X]\n",j, stream->spec.position, target_event, *target_event, *buffer); 
    26212535                                        buffer++; 
    26222536                                        target_event+=dimension; 
     
    26242538                                break; 
    26252539                        case freebob_buffer_type_float: 
    2626 //                              assert(nsamples>=4); 
    26272540                                j=0; 
    26282541                                if(nsamples>3) { 
    2629                                         for(j = 0; j < nsamples-4; j += 4) { 
     2542                                        for(j = 0; j < nsamples-3; j += 4) { 
    26302543                                                tmp[0] = ntohl(*target_event); 
    26312544                                                target_event += dimension; 
     
    26532566                                        } 
    26542567                                } 
    2655                                 if (j != nsamples) { 
    2656                                         for(; j < nsamples; ++j) { // decode max nsamples 
    2657                                                 unsigned int v = ntohl(*target_event) & 0x00FFFFFF; 
    2658                                                 // sign-extend highest bit of 24-bit int 
    2659                                                 int tmp = (int)(v << 8) / 256; 
    2660                                                 *floatbuff = tmp * multiplier; 
    2661          
    2662                                                 floatbuff++; 
    2663                                                 target_event += dimension; 
    2664                                         } 
     2568                                for(; j < nsamples; ++j) { // decode max nsamples 
     2569                                        unsigned int v = ntohl(*target_event) & 0x00FFFFFF; 
     2570                                        // sign-extend highest bit of 24-bit int 
     2571                                        int tmp = (int)(v << 8) / 256; 
     2572                                        *floatbuff = tmp * multiplier; 
     2573 
     2574                                        floatbuff++; 
     2575                                        target_event += dimension; 
    26652576                                } 
    26662577                                asm volatile("emms"); 
     
    27932704                                j=0; 
    27942705                                if(read>3) { 
    2795                                         for (j = 0; j < read-4; j += 4) { 
     2706                                        for (j = 0; j < read-3; j += 4) { 
    27962707                                                asm("movups %[floatbuff], %%xmm0\n\t" 
    27972708                                                                "mulps %[ssemult], %%xmm0\n\t" 
     
    28202731                                        } 
    28212732                                } 
    2822                                 if (j != read) { 
    2823                                         for(; j < read; ++j) { 
    2824                                         // don't care for overflow 
    2825                                                 float v = *floatbuff * multiplier;  // v: -231 .. 231 
    2826                                                 unsigned int tmp = (int)v; 
    2827                                                 *target_event = htonl((tmp >> 8) | 0x40000000); 
    2828                          
    2829                                                 floatbuff++; 
    2830                                                 target_event += dimension; 
    2831                                         }                                
     2733                                for(; j < read; ++j) { 
     2734                                // don't care for overflow 
     2735                                        float v = *floatbuff * multiplier;  // v: -231 .. 231 
     2736                                        unsigned int tmp = (int)v; 
     2737                                        *target_event = htonl((tmp >> 8) | 0x40000000); 
     2738                 
     2739                                        floatbuff++; 
     2740                                        target_event += dimension; 
    28322741                                } 
     2742 
    28332743                                asm volatile("emms"); 
    28342744                                break; 
  • trunk/libfreebob/tests/streaming/testmidistreaming1.c

    r160 r194  
    159159        dev_options.nb_buffers=3; 
    160160 
    161         dev_options.iso_buffers=100; 
    162         dev_options.iso_prebuffers=8; 
    163         dev_options.iso_irq_interval=8; 
    164          
    165161        dev_options.port=1; 
    166162        dev_options.node_id=-1; 
  • trunk/libfreebob/tests/streaming/teststreaming.c

    r185 r194  
    7373        dev_options.nb_buffers=3; 
    7474 
    75         dev_options.iso_buffers=100; 
    76         dev_options.iso_prebuffers=8; 
    77         dev_options.iso_irq_interval=8; 
    78          
    7975        dev_options.port=0; 
    8076        dev_options.node_id=-1; 
  • trunk/libfreebob/tests/streaming/teststreaming2.c

    r183 r194  
    7676        dev_options.nb_buffers=3; 
    7777 
    78         dev_options.iso_buffers=100; 
    79         dev_options.iso_prebuffers=8; 
    80         dev_options.iso_irq_interval=8; 
    81          
    8278        dev_options.port=1; 
    8379        dev_options.node_id=-1; 
  • trunk/libfreebob/tests/streaming/teststreaming3.c

    r185 r194  
    7878        dev_options.nb_buffers=3; 
    7979 
    80         dev_options.iso_buffers=40; 
    81         dev_options.iso_prebuffers=4; 
    82         dev_options.iso_irq_interval=2; 
    83          
    8480        dev_options.port=0; 
    8581        dev_options.node_id=-1;