Changeset 552

Show
Ignore:
Timestamp:
03/25/08 23:32:36 (5 months ago)
Author:
conrad
Message:

formatting, comments

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • libremix/trunk/src/ctxdata/cd_scalar.c

    r161 r552  
    2222 
    2323/* 
    24  * CDSet: A keyed set implementation. 
     24 * CDScalar: Polymorphic scalar values 
    2525 * 
    2626 * Conrad Parker <Conrad.Parker@CSIRO.AU>, August 2001 

  • libremix/trunk/src/libremix/remix_base.c

    r161 r552  
    135135 
    136136  remix_dprintf ("[remix_set_parameter] base %p, [%d] ==> %p\n", base, key, 
    137              parameter.s_pointer); 
     137                 parameter.s_pointer); 
    138138  base->parameters = cd_set_replace (env, base->parameters, key, parameter); 
    139139  return parameter; 
    …… 
    153153  p = cd_set_find (env, base->parameters, key); 
    154154  remix_dprintf ("[remix_get_parameter] base %p, [%d] == %p\n", base, key, 
    155              p.s_pointer); 
     155                 p.s_pointer); 
    156156  return p; 
    157157} 

  • libremix/trunk/src/libremix/remix_chunk.c

    r161 r552  
    4545#include "remix.h" 
    4646 
    47 typedef RemixCount (*RemixPFunc) (RemixPCM * src, RemixCount count, void * data); 
    48 typedef RemixCount (*RemixPPFunc) (RemixPCM * src, RemixPCM * dest, RemixCount count, 
     47typedef RemixCount 
     48  (*RemixPFunc) (RemixPCM * src, RemixCount count, void * data); 
     49 
     50typedef RemixCount 
     51  (*RemixPPFunc) (RemixPCM * src, RemixPCM * dest, RemixCount count, 
    4952                             void * data); 
    50 typedef RemixCount (*RemixPPPFunc) (RemixPCM * src1, RemixPCM * src2, RemixPCM * dest, 
    51                               RemixCount count, void * data); 
     53typedef RemixCount 
     54  (*RemixPPPFunc) (RemixPCM * src1, RemixPCM * src2, RemixPCM * dest, 
     55                   RemixCount count, void * data); 
     56 
    5257 
    5358RemixChunk * 
    …… 
    6671 
    6772RemixChunk * 
    68 remix_chunk_new_from_buffer (RemixEnv * env, RemixCount start_index, RemixCount length, 
    69                         RemixPCM * buffer) 
     73remix_chunk_new_from_buffer (RemixEnv * env, RemixCount start_index, 
     74                             RemixCount length, RemixPCM * buffer) 
    7075{ 
    7176  RemixChunk * u; 
    …… 
    115120 
    116121static RemixCount 
    117 _remix_pfunc_apply (RemixEnv * env, RemixPFunc func, RemixChunk * chunk, RemixCount start, 
    118                 RemixCount count, void * data) 
     122_remix_pfunc_apply (RemixEnv * env, RemixPFunc func, RemixChunk * chunk, 
     123                    RemixCount start, RemixCount count, void * data) 
    119124{ 
    120125  RemixCount chunk_start = start - chunk->start_index; 
    …… 
    136141 
    137142/* 
    138  * _remix_ppfunc_apply (src, src_offset, dest, dest_offset, count, func) 
     143 * _remix_ppfunc_apply (env, func, src, src_offset, dest, dest_offset, count, 
     144 *                      data) 
    139145 * 
    140146 * Apply RemixPCMPCMFunc 'func' to 'count' samples of chunks 'src' and 'dest'. 
    …… 
    142148static RemixCount 
    143149_remix_ppfunc_apply (RemixEnv * env, RemixPPFunc func, 
    144                  RemixChunk * src, RemixCount src_offset, 
    145                  RemixChunk * dest, RemixCount dest_offset, RemixCount count, 
    146                 void * data) 
     150                     RemixChunk * src, RemixCount src_offset, 
     151                     RemixChunk * dest, RemixCount dest_offset, 
     152                     RemixCount count, void * data) 
    147153{ 
    148154  RemixCount dest_start = dest_offset - dest->start_index; 
    …… 
    175181 
    176182/* 
    177  * _remix_pppfunc_apply (src, src_offset, dest, dest_offset, count, func) 
     183 * _remix_pppfunc_apply (env, func, src, src_offset, dest, dest_offset, count, 
     184 *                       data) 
    178185 * 
    179186 * Apply RemixPPPFunc 'func' to 'count' samples of chunks 'src1', 'src2' 
    …… 
    182189static RemixCount 
    183190_remix_pppfunc_apply (RemixEnv * env, RemixPPPFunc func, 
    184                   RemixChunk * src1, RemixCount src1_offset, 
    185                   RemixChunk * src2, RemixCount src2_offset, 
    186                   RemixChunk * dest, RemixCount dest_offset, 
    187                   RemixCount count, void * data) 
     191                      RemixChunk * src1, RemixCount src1_offset, 
     192                      RemixChunk * src2, RemixCount src2_offset, 
     193                      RemixChunk * dest, RemixCount dest_offset, 
     194                      RemixCount count, void * data) 
    188195{ 
    189196  RemixCount dest_start = dest_offset - dest->start_index; 
    …… 
    230237 */ 
    231238RemixCount 
    232 _remix_chunk_clear_region (RemixEnv * env, RemixChunk * chunk, RemixCount start, 
    233                         RemixCount length, int channelname, void * unused) 
     239_remix_chunk_clear_region (RemixEnv * env, RemixChunk * chunk, 
     240                           RemixCount start, RemixCount length, 
     241                           int channelname, void * unused) 
    234242{ 
    235243  return _remix_pfunc_apply (env,_remix_pcm_clear_region, 
    236                           chunk, start, length, NULL); 
    237                            
    238 } 
    239  
    240 RemixCount 
    241 _remix_chunk_gain (RemixEnv * env, RemixChunk * chunk, RemixCount start, RemixCount count, 
    242                 int channelname, /* (RemixPCM *) */ void * gain) 
     244                             chunk, start, length, NULL); 
     245} 
     246 
     247/* 
     248 * _remix_chunk_gain (chunk, start, length, gain) 
     249 * 
     250 * Multiply by gain all samples in 'chunk' from stream index 'start' for 
     251 * 'length' samples. 
     252 * Returns the count of samples modified. 
     253 */ 
     254RemixCount 
     255_remix_chunk_gain (RemixEnv * env, RemixChunk * chunk, 
     256                   RemixCount start, RemixCount count, 
     257                   int channelname, /* (RemixPCM *) */ void * gain) 
    243258{ 
    244259  return _remix_pfunc_apply (env, _remix_pcm_gain, chunk, start, count, gain); 
    …… 
    249264 
    250265/* 
    251  * _remix_chunk_copy (src, dest, offset, count, unused) 
     266 * _remix_chunk_copy (env, src+offset, dest+offset, count, channelname) 
    252267 * 
    253268 * Copy data from 'src' to 'dest' from stream index 'offset' for 
    …… 
    256271RemixCount 
    257272_remix_chunk_copy (RemixEnv * env, RemixChunk * src, RemixCount src_offset, 
    258                RemixChunk * dest, RemixCount dest_offset, RemixCount count, 
    259                int channelname, void * unused) 
     273                   RemixChunk * dest, RemixCount dest_offset, RemixCount count, 
     274                   int channelname, void * unused) 
    260275{ 
    261276  return _remix_ppfunc_apply (env, _remix_pcm_copy, src, src_offset, 
    262                           dest, dest_offset, count, NULL); 
    263 } 
    264  
    265 /* 
    266  * _remix_chunk_add_inplace (src, dest, start, count, unused) 
     277                              dest, dest_offset, count, NULL); 
     278} 
     279 
     280/* 
     281 * _remix_chunk_add_inplace (env, src+offset, dest+offset, count, channelname) 
    267282 * 
    268283 * Add data from 'src' to data in 'dest' from stream index 'start' for 
    …… 
    270285 */ 
    271286RemixCount 
    272 _remix_chunk_add_inplace (RemixEnv * env, RemixChunk * src, RemixCount src_offset, 
    273                        RemixChunk * dest, RemixCount dest_offset, RemixCount count, 
    274                        int channelname, void * unused) 
     287_remix_chunk_add_inplace (RemixEnv * env, 
     288                          RemixChunk * src, RemixCount src_offset, 
     289                          RemixChunk * dest, RemixCount dest_offset, 
     290                          RemixCount count, int channelname, void * unused) 
    275291{ 
    276292  return _remix_ppfunc_apply (env, _remix_pcm_add, src, src_offset, 
    …… 
    286302 */ 
    287303RemixCount 
    288 _remix_chunk_mult_inplace (RemixEnv * env, RemixChunk * src, RemixCount src_offset, 
    289                         RemixChunk * dest, RemixCount dest_offset, RemixCount count, 
    290                         int channelname, void * unused) 
     304_remix_chunk_mult_inplace (RemixEnv * env, 
     305                           RemixChunk * src, RemixCount src_offset, 
     306                           RemixChunk * dest, RemixCount dest_offset, 
     307                           RemixCount count, int channelname, void * unused) 
    291308{ 
    292309  return _remix_ppfunc_apply (env, _remix_pcm_mult, src, src_offset, 
    …… 
    301318 */ 
    302319RemixCount 
    303 _remix_chunk_fade_inplace (RemixEnv * env, RemixChunk * src, RemixCount src_offset, 
    304                         RemixChunk * dest, RemixCount dest_offset, RemixCount count, 
    305                         int channelname, void * unused) 
     320_remix_chunk_fade_inplace (RemixEnv * env, 
     321                           RemixChunk * src, RemixCount src_offset, 
     322                           RemixChunk * dest, RemixCount dest_offset, 
     323                           RemixCount count, int channelname, void * unused) 
    306324{ 
    307325  return _remix_ppfunc_apply (env, _remix_pcm_fade, src, src_offset, 
    …… 
    310328 
    311329/* 
    312  * _remix_chunk_interleave_2 (env, src1, src1_offset, src2, src2_offset, 
    313  *                         count, dest) 
     330 * _remix_chunk_interleave_2 (env, src1+offset, src2+offset, count, dest) 
    314331 * 
    315332 * Interleave data of 'src1' from stream index 'src1_offset' with that 
    …… 
    320337 */ 
    321338RemixCount 
    322 _remix_chunk_interleave_2 (RemixEnv * env, RemixChunk * src1, RemixCount src1_offset, 
    323                         RemixChunk * src2, RemixCount src2_offset, RemixCount count, 
    324                         int unused, void * dest) 
     339_remix_chunk_interleave_2 (RemixEnv * env, 
     340                           RemixChunk * src1, RemixCount src1_offset, 
     341                           RemixChunk * src2, RemixCount src2_offset, 
     342                           RemixCount count, int unused, void * dest) 
    325343{ 
    326344  return _remix_ppfunc_apply (env, _remix_pcm_interleave_2, src1, src1_offset, 
    327                            src2, src2_offset, count, dest); 
    328 } 
    329  
    330 /* 
    331  * _remix_chunk_deinterleave_2 (env, dest1, dest1_offset, dest2, dest2_offset, 
    332  *                           count, src) 
     345                              src2, src2_offset, count, dest); 
     346} 
     347 
     348/* 
     349 * _remix_chunk_deinterleave_2 (env, dest1+offset, dest2+offset, count, src) 
    333350 * 
    334351 * Deinterleave data of 'src' and store the result in streams 'dest1' (from 
    …… 
    339356 */ 
    340357RemixCount 
    341 _remix_chunk_deinterleave_2 (RemixEnv * env, RemixChunk * dest1, RemixCount dest1_offset, 
    342                           RemixChunk * dest2, RemixCount dest2_offset, RemixCount count, 
    343                           int unused, void * src) 
    344 { 
    345   return _remix_ppfunc_apply (env, _remix_pcm_deinterleave_2, dest1, dest1_offset, 
    346                            dest2, dest2_offset, count, src); 
     358_remix_chunk_deinterleave_2 (RemixEnv * env, 
     359                             RemixChunk * dest1, RemixCount dest1_offset, 
     360                             RemixChunk * dest2, RemixCount dest2_offset, 
     361                             RemixCount count, int unused, void * src) 
     362{ 
     363  return _remix_ppfunc_apply (env, _remix_pcm_deinterleave_2, 
     364                              dest1, dest1_offset, dest2, dest2_offset, 
     365                              count, src); 
    347366} 
    348367 
    …… 
    350369 
    351370/* 
    352  * _remix_chunk_blend_inplace (src, src_offset, blend, blend_offset, 
    353  *                          dest, dest_offset, count, unused) 
     371 * _remix_chunk_blend_inplace (env, src+offset, blend+offset, 
     372 *                             dest+offset, count, unused) 
    354373 * 
    355374 * Blend data of 'src' into that of 'dest' by blend values given in 
    …… 
    357376 */ 
    358377RemixCount 
    359 _remix_chunk_blend_inplace (RemixEnv * env, RemixChunk * src, RemixCount src_offset, 
    360                          RemixChunk * blend, RemixCount blend_offset, 
    361                          RemixChunk * dest, RemixCount dest_offset, RemixCount count, 
    362                          int channelname, void * unused) 
     378_remix_chunk_blend_inplace (RemixEnv * env, 
     379                            RemixChunk * src, RemixCount src_offset, 
     380                            RemixChunk * blend, RemixCount blend_offset, 
     381                            RemixChunk * dest, RemixCount dest_offset, 
     382                            RemixCount count, int channelname, void * unused) 
    363383{ 
    364384  return _remix_pppfunc_apply (env, _remix_pcm_blend, src, src_offset, 
    365                            blend, blend_offset, dest, dest_offset, 
    366                            count, NULL); 
    367 } 
     385                               blend, blend_offset, dest, dest_offset, 
     386                               count, NULL); 
     387} 

  • libremix/trunk/src/libremix/remix_deck.c

    r161 r552  
    148148    track = (RemixBase *)l->data.s_pointer; 
    149149    length = remix_length (env, track); 
    150     remix_dprintf ("[remix_deck_length] found track %p length %ld\n", track, length); 
     150    remix_dprintf ("[remix_deck_length] found track %p length %ld\n", 
     151                   track, length); 
    151152    maxlength = MAX (maxlength, length); 
    152153  } 
    …… 
    211212static RemixCount 
    212213remix_deck_process (RemixEnv * env, RemixBase * base, RemixCount count, 
    213                 RemixStream * input, RemixStream * output) 
     214                    RemixStream * input, RemixStream * output) 
    214215{ 
    215216  RemixDeck * deck = (RemixDeck *)base; 
    …… 
    224225 
    225226  remix_dprintf ("PROCESS DECK (%p, +%ld, %p -> %p) @ %ld\n", 
    226              deck, count, input, output, current_offset); 
     227                 deck, count, input, output, current_offset); 
    227228 
    228229  while (remaining > 0) { 
    …… 
    263264static RemixCount 
    264265remix_deck_twotrack_process (RemixEnv * env, RemixBase * base, RemixCount count, 
    265                          RemixStream * input, RemixStream * output) 
     266                             RemixStream * input, RemixStream * output) 
    266267{ 
    267268  RemixDeck * deck = (RemixDeck *)base; 
    …… 
    275276 
    276277  remix_dprintf ("PROCESS DECK [twotrack] (%p, +%ld, %p -> %p) @ %ld\n", 
    277              deck, count, input, output, current_offset); 
     278                 deck, count, input, output, current_offset); 
    278279 
    279280  l = deck->tracks; 
    …… 
    306307static RemixCount 
    307308remix_deck_onetrack_process (RemixEnv * env, RemixBase * base, RemixCount count, 
    308                          RemixStream * input, RemixStream * output) 
     309                             RemixStream * input, RemixStream * output) 
    309310{ 
    310311  RemixDeck * deck = (RemixDeck *)base; 
    …… 
    313314 
    314315  remix_dprintf ("PROCESS DECK [onetrack] (%p, +%ld, %p -> %p) @ %ld\n", 
    315              deck, count, input, output, remix_tell (env, base)); 
     316                 deck, count, input, output, remix_tell (env, base)); 
    316317 
    317318  n = remix_process (env, (RemixBase *)track, count, input, output); 
    318319 
    319320  remix_dprintf ("*** deck @ %ld\ttrack @ %ld\n", remix_tell (env, base), 
    320               remix_tell (env, (RemixBase *)track)); 
     321                 remix_tell (env, (RemixBase *)track)); 
    321322 
    322323  remix_dprintf ("[remix_deck_onetrack_process] processed %ld\n", n); 

  • libremix/trunk/src/libremix/remix_envelope.c

    r161 r552  
    3232/* Optimisation dependencies: optimise when adding and removing points 
    3333 * or changing envelope type */ 
    34 static RemixEnvelope * remix_envelope_optimise (RemixEnv * env, RemixEnvelope * envelope); 
     34static RemixEnvelope * 
     35remix_envelope_optimise (RemixEnv * env, RemixEnvelope * envelope); 
    3536 
    3637static void 
    …… 
    111112remix_envelope_new (RemixEnv * env, RemixEnvelopeType type) 
    112113{ 
    113   RemixEnvelope * envelope = 
    114     (RemixEnvelope *)remix_base_new_subclass (env, sizeof (struct _RemixEnvelope)); 
     114  RemixEnvelope * envelope = (RemixEnvelope *) 
     115    remix_base_new_subclass (env, sizeof (struct _RemixEnvelope)); 
    115116  remix_envelope_init (env, (RemixBase *)envelope); 
    116117  envelope->type = type; 
    …… 
    184185 
    185186RemixPoint * 
    186 remix_envelope_add_point (RemixEnv * env, RemixEnvelope * envelope, RemixTime time, 
    187                       RemixPCM value) 
     187remix_envelope_add_point (RemixEnv * env, RemixEnvelope * envelope, 
     188                          RemixTime time, RemixPCM value) 
    188189{ 
    189190  RemixPoint * point = remix_point_new (time, value); 
    …… 
    214215 
    215216RemixEnvelope * 
    216 remix_envelope_remove_point (RemixEnv * env, RemixEnvelope * envelope, RemixPoint * point) 
     217remix_envelope_remove_point (RemixEnv * env, RemixEnvelope * envelope, 
     218                             RemixPoint * point) 
    217219{ 
    218220  envelope->points = cd_list_remove (env, envelope->points, 
    …… 
    254256static CDList * 
    255257remix_envelope_point_item_before (RemixEnv * env, RemixEnvelope * envelope, 
    256                               RemixCount offset) 
     258                                  RemixCount offset) 
    257259{ 
    258260  CDList * l, * lp = RemixNone; 
    …… 
    263265    point = (RemixPoint *)l->data.s_pointer; 
    264266    ptime = remix_time_convert (env, point->time, envelope->timetype, 
    265                             REMIX_TIME_SAMPLES); 
     267                                REMIX_TIME_SAMPLES); 
    266268    if (ptime.samples > offset) break; 
    267269    lp = l; 
    …… 
    271273 
    272274static RemixCount 
    273 remix_envelope_constant_write_chunk (RemixEnv * env, RemixChunk * chunk, RemixCount offset, 
    274                                   RemixCount count, int channelname, void * data) 
     275remix_envelope_constant_write_chunk (RemixEnv * env, RemixChunk * chunk, 
     276                                     RemixCount offset, RemixCount count, 
     277                                     int channelname, void * data) 
    275278{ 
    276279  RemixEnvelope * envelope = (RemixEnvelope *)data; 
    …… 
    291294#if 0 
    292295static RemixCount 
    293 remix_envelope_spline_write_chunk (RemixEnv * env, RemixChunk * chunk, RemixCount offset, 
    294                                 RemixCount count, int channelname, void * data) 
     296remix_envelope_spline_write_chunk (RemixEnv * env, RemixChunk * chunk, 
     297                                   RemixCount offset, RemixCount count, 
     298                                   int channelname, void * data) 
    295299{ 
    296300  RemixEnvelope * envelope = (RemixEnvelope *)data; 
    …… 
    300304#endif 
    301305 
    302 /* An RemixChunkFunc for creating envelope data */ 
    303 static RemixCount 
    304 remix_envelope_linear_write_chunk (RemixEnv * env, RemixChunk * chunk, RemixCount offset, 
    305                                 RemixCount count, int channelname, void * data) 
     306/* A RemixChunkFunc for creating envelope data */ 
     307static RemixCount 
     308remix_envelope_linear_write_chunk (RemixEnv * env, RemixChunk * chunk, 
     309                                   RemixCount offset, RemixCount count, 
     310                                   int channelname, void * data) 
    306311{ 
    307312  RemixEnvelope * envelope = (RemixEnvelope *)data; 
    …… 
    342347 
    343348  point = (RemixPoint *)l->data.s_pointer; 
    344   t = remix_time_convert (env, point->time, envelope->timetype, REMIX_TIME_SAMPLES); 
     349  t = remix_time_convert (env, point->time, envelope->timetype, 
     350                          REMIX_TIME_SAMPLES); 
    345351  px = t.samples; 
    346352  py = point->value; 
    …… 
    348354  next_point = (RemixPoint *)nl->data.s_pointer; 
    349355  t = remix_time_convert (env, next_point->time, envelope->timetype, 
    350                       REMIX_TIME_SAMPLES); 
     356                          REMIX_TIME_SAMPLES); 
    351357  npx = t.samples; 
    352358  npy = next_point->value; 
    …… 
    362368     
    363369    d = &chunk->data[offset]; 
    364     /*    _remix_pcm_write_linear (d, px - chunk->start_index, py, gradient, n);*/ 
     370    /*  _remix_pcm_write_linear (d, px - chunk->start_index, py, gradient, n);*/ 
    365371    n = _remix_pcm_write_linear (d, px, py, npx, npy, pos, n); 
    366372     
    …… 
    376382      next_point = (RemixPoint *)nl->data.s_pointer; 
    377383      t = remix_time_convert (env, next_point->time, envelope->timetype, 
    378                           REMIX_TIME_SAMPLES); 
     384                              REMIX_TIME_SAMPLES); 
    379385      npx = t.samples; 
    380386      npy = next_point->value; 
    …… 
    389395 
    390396static RemixCount 
    391 remix_envelope_constant_process (RemixEnv * env, RemixBase * base, RemixCount count, 
    392                               RemixStream * input, RemixStream * output) 
     397remix_envelope_constant_process (RemixEnv * env, RemixBase * base, 
     398                                 RemixCount count, RemixStream * input, 
     399                                 RemixStream * output) 
    393400{ 
    394401  RemixEnvelope * envelope = (RemixEnvelope *)base; 
    395402  return remix_stream_chunkfuncify (env, output, count, 
    396                                  remix_envelope_constant_write_chunk, envelope); 
    397 } 
    398  
    399 static RemixCount 
    400 remix_envelope_spline_process (RemixEnv * env, RemixBase * base, RemixCount count, 
    401                             RemixStream * input, RemixStream * output) 
    402 { 
     403                                    remix_envelope_constant_write_chunk, 
     404                                    envelope); 
     405} 
     406 
     407static RemixCount 
     408remix_envelope_spline_process (RemixEnv * env, RemixBase * base, 
     409                               RemixCount count, RemixStream * input, 
     410                               RemixStream * output) 
     411{ 
     412  /* XXX: Implement */ 
    403413  return -1; 
    404414} 
    405415 
    406416static RemixCount 
    407 remix_envelope_linear_process (RemixEnv * env, RemixBase * base, RemixCount count, 
    408                             RemixStream * input, RemixStream * output) 
     417remix_envelope_linear_process (RemixEnv * env, RemixBase * base, 
     418                               RemixCount count, RemixStream * input, 
     419                               RemixStream * output) 
    409420{ 
    410421  RemixEnvelope * envelope = (RemixEnvelope *)base; 
    411422  return remix_stream_chunkfuncify (env, output, count, 
    412                                  remix_envelope_linear_write_chunk, envelope); 
     423                                    remix_envelope_linear_write_chunk, 
     424                                    envelope); 
    413425} 
    414426 
    415427static RemixCount 
    416428remix_envelope_process (RemixEnv * env, RemixBase * base, RemixCount count, 
    417                     RemixStream * input, RemixStream * output) 
     429                        RemixStream * input, RemixStream * output) 
    418430{ 
    419431  RemixEnvelope * envelope = (RemixEnvelope *)base; 
    …… 
    439451  RemixTime duration = remix_envelope_get_duration (env, envelope); 
    440452  RemixTime t = remix_time_convert (env, duration, envelope->timetype, 
    441                              REMIX_TIME_SAMPLES); 
     453                                    REMIX_TIME_SAMPLES); 
    442454  return t.samples; 
    443455} 

  • libremix/trunk/src/libremix/remix_layer.c

    r161 r552  
    8787_remix_layer_new (RemixEnv * env) 
    8888{ 
    89   return (RemixBase *) remix_base_new_subclass (env, sizeof (struct _RemixLayer)); 
     89  return (RemixBase *) 
     90    remix_base_new_subclass (env, sizeof (struct _RemixLayer)); 
    9091} 
    9192 
    …… 
    437438 
    438439  remix_dprintf ("[remix_layer_length] (%p) last sound ends at %d ticks == %ld samples\n", 
    439              layer, end.beat24s, t.samples); 
     440                 layer, end.beat24s, t.samples); 
    440441 
    441442  return t.samples; 

  • libremix/trunk/src/libremix/remix_null.c

    r161 r552  
    2222 
    2323/* 
    24  * RemixNull: An RemixBase with no processing 
     24 * RemixNull: A RemixBase with no processing 
    2525 * 
    2626 * Conrad Parker <Conrad.Parker@CSIRO.AU>, August 2001 
    …… 
    5656RemixCount 
    5757remix_null_process (RemixEnv * env, RemixBase * base, RemixCount count, 
    58                 RemixStream * input, RemixStream * output) 
     58                    RemixStream * input, RemixStream * output) 
    5959{ 
    6060  remix_set_error (env, REMIX_ERROR_NOOP); 

  • libremix/trunk/src/libremix/remix_pcm.c

    r161 r552  
    9898 */ 
    9999RemixCount 
    100 _remix_pcm_copy (RemixPCM * src, RemixPCM * dest, RemixCount count, void * unused) 
     100_remix_pcm_copy (RemixPCM * src, RemixPCM * dest, RemixCount count, 
     101                 void * unused) 
    101102{ 
    102103  memcpy (dest, src, count * sizeof (RemixPCM)); 
    …… 
    110111 */ 
    111112RemixCount 
    112 _remix_pcm_add (RemixPCM * src, RemixPCM * dest, RemixCount count, void * unused) 
     113_remix_pcm_add (RemixPCM * src, RemixPCM * dest, RemixCount count, 
     114                void * unused) 
    113115{ 
    114116  RemixCount i; 
    …… 
    127129 */ 
    128130RemixCount 
    129 _remix_pcm_mult (RemixPCM * src, RemixPCM * dest, RemixCount count, void * unused) 
     131_remix_pcm_mult (RemixPCM * src, RemixPCM * dest, RemixCount count, 
     132                 void * unused) 
    130133{ 
    131134  RemixCount i; 
    …… 
    144147 */ 
    145148RemixCount 
    146 _remix_pcm_fade (RemixPCM * src, RemixPCM * dest, RemixCount count, void * unused) 
     149_remix_pcm_fade (RemixPCM * src, RemixPCM * dest, RemixCount count, 
     150                 void * unused) 
    147151{ 
    148152  RemixCount i; 
    …… 
    161165 */ 
    162166RemixCount 
    163 _remix_pcm_interleave_2 (RemixPCM * src1, RemixPCM * src2, RemixCount count, void * data) 
     167_remix_pcm_interleave_2 (RemixPCM * src1, RemixPCM * src2, RemixCount count, 
     168                         void * data) 
    164169{ 
    165170  RemixPCM * dest = (RemixPCM *)data; 
    …… 
    180185 */ 
    181186RemixCount 
    182 _remix_pcm_deinterleave_2 (RemixPCM * dest1, RemixPCM * dest2, RemixCount count, void * data) 
     187_remix_pcm_deinterleave_2 (RemixPCM * dest1, RemixPCM * dest2, 
     188                           RemixCount count, void * data) 
    183189{ 
    184190  RemixPCM * src = (RemixPCM *)data; 
    …… 
    201207 */ 
    202208RemixCount 
    203 _remix_pcm_blend (RemixPCM * src, RemixPCM * blend, RemixPCM * dest, RemixCount count, 
    204               void * unused) 
     209_remix_pcm_blend (RemixPCM * src, RemixPCM * blend, RemixPCM * dest, 
     210                  RemixCount count, void * unused) 
    205211{ 
    206212  RemixCount i; 
    …… 
    226232 */ 
    227233RemixCount 
    228 _remix_pcm_write_linear (RemixPCM * data, RemixCount x1, RemixPCM y1, RemixCount x2, RemixPCM y2, 
    229                       RemixCount offset, RemixCount count) 
     234_remix_pcm_write_linear (RemixPCM * data, RemixCount x1, RemixPCM y1, 
     235                         RemixCount x2, RemixPCM y2, 
     236                         RemixCount offset, RemixCount count) 
    230237{ 
    231238  RemixCount i; 
    232239 
    233240  remix_dprintf ("[remix_pcm_write_linear] ((%ld, %f) -> (%ld, %f), %ld +%ld)\n", 
    234          x1, y1, x2, y2, offset, count); 
     241                 x1, y1, x2, y2, offset, count); 
    235242 
    236243  for (i = 0; i < count; i++) { 

  • libremix/trunk/src/libremix/remix_sound.c

    r161 r552  
    106106 
    107107RemixBase * 
    108 remix_sound_clone_with_layer (RemixEnv * env, RemixBase * base, RemixLayer * new_layer) 
     108remix_sound_clone_with_layer (RemixEnv * env, RemixBase * base, 
     109                              RemixLayer * new_layer) 
    109110{ 
    110111  RemixSound * sound = (RemixSound *)base; 
    …… 
    253254 
    254255RemixTime 
    255 remix_sound_set_start_time (RemixEnv * env, RemixSound * sound, RemixTime start_time) 
     256remix_sound_set_start_time (RemixEnv * env, RemixSound * sound, 
     257                            RemixTime start_time) 
    256258{ 
    257259  RemixTime old = sound->start_time; 
    …… 
    269271 
    270272RemixTime 
    271 remix_sound_set_duration (RemixEnv * env, RemixSound * sound, RemixTime duration) 
     273remix_sound_set_duration (RemixEnv * env, RemixSound * sound, 
     274                          RemixTime duration) 
    272275{ 
    273276  RemixTime old = sound->duration; 
    …… 
    371374static RemixCount 
    372375_remix_sound_get_raw (RemixEnv * env, RemixSound * sound, RemixCount offset, 
    373                      RemixCount count, RemixStream * input, RemixStream * output) 
     376                      RemixCount count, RemixStream * input, 
     377                      RemixStream * output) 
    374378{ 
    375379  RemixCount block, n; 
    …… 
    454458 
    455459static RemixCount 
    456 remix_sound_process (RemixEnv * env, RemixBase * base, RemixCount count, RemixStream * input, 
    457                   RemixStream * output) 
     460remix_sound_process (RemixEnv * env, RemixBase * base, RemixCount count, 
     461                     RemixStream * input, RemixStream * output) 
    458462{ 
    459463  RemixSound * sound = (RemixSound *)base; 

  • libremix/trunk/src/libremix/remix_squaretone.c

    r177 r552  
    8484remix_squaretone_new (RemixEnv * env, float frequency) 
    8585{ 
    86   RemixSquareTone * squaretone = 
    87     (RemixSquareTone *)remix_base_new_subclass (env, sizeof (struct _RemixSquareTone)); 
     86  RemixSquareTone * squaretone = (RemixSquareTone *) 
     87    remix_base_new_subclass (env, sizeof (struct _RemixSquareTone)); 
    8888  remix_squaretone_init (env, (RemixBase *)squaretone); 
    8989  squaretone->frequency = frequency; 
    …… 
    144144/* An RemixChunkFunc for creating squaretone data */ 
    145145static RemixCount 
    146 remix_squaretone_write_chunk (RemixEnv * env, RemixChunk * chunk, RemixCount offset, 
    147                            RemixCount count, int channelname, void * data) 
     146remix_squaretone_write_chunk (RemixEnv * env, RemixChunk * chunk, 
     147                              RemixCount offset, RemixCount count, 
     148                              int channelname, void * data) 
    148149{ 
    149150  RemixSquareTone * squaretone = (RemixSquareTone *)data; 
    …… 
    154155  CDScalar k; 
    155156 
    156   remix_dprintf ("[remix_squaretone_write_chunk] (+%ld) @ %ld\n", count, offset); 
     157  remix_dprintf ("[remix_squaretone_write_chunk] (+%ld) @ %ld\n", 
     158                 count, offset); 
    157159 
    158160  k = cd_set_find (env, squaretone->channels, channelname); 
    …… 
    161163  if (sqch == RemixNone) { 
    162164    remix_dprintf ("[remix_squaretone_write_chunk] channel %d not found\n", 
    163                channelname); 
     165                   channelname); 
    164166    remix_set_error (env, REMIX_ERROR_SILENCE); 
    165167    return -1; 
    …… 
    169171 
    170172  remix_dprintf ("[remix_squaretone_write_chunk] wavelength %ld, cycle_offset %ld\n", 
    171              wavelength, sqch->_cycle_offset); 
     173                 wavelength, sqch->_cycle_offset); 
    172174   
    173175  if (sqch->_cycle_offset < wavelength/2) { 
    …… 
    201203static RemixCount 
    202204remix_squaretone_process (RemixEnv * env, RemixBase * base, RemixCount count, 
    203                       RemixStream * input, RemixStream * output) 
     205                          RemixStream * input, RemixStream * output) 
    204206{ 
    205207  RemixSquareTone * squaretone = (RemixSquareTone *)base; 
    206208  return remix_stream_chunkfuncify (env, output, count, 
    207                                 remix_squaretone_write_chunk, squaretone); 
     209                                    remix_squaretone_write_chunk, squaretone); 
    208210} 
    209211 

  • libremix/trunk/src/libremix/remix_stream.c

    r168 r552  
    202202 
    203203RemixStream * 
    204 remix_stream_add_chunks (RemixEnv * env, RemixStream * stream, RemixCount offset, 
    205                     RemixCount length) 
     204remix_stream_add_chunks (RemixEnv * env, RemixStream * stream, 
     205                         RemixCount offset, RemixCount length) 
    206206{ 
    207207  CDSet * s; 
    …… 
    255255static RemixCount 
    256256remix_stream_process (RemixEnv * env, RemixBase * base, RemixCount count, 
    257                   RemixStream * input, RemixStream * output) 
     257                      RemixStream * input, RemixStream * output) 
    258258{ 
    259259  RemixStream * stream = (RemixStream *)base; 
    …… 
    400400RemixCount 
    401401remix_stream_chunkchunkchunkfuncify (RemixEnv * env, 
    402                                  RemixStream * src1, RemixStream * src2, 
    403                                  RemixStream * dest, RemixCount count, 
    404                                  RemixChunkChunkChunkFunc func, void * data) 
     402                                     RemixStream * src1, RemixStream * src2, 
     403                                     RemixStream * dest, RemixCount count, 
     404                                     RemixChunkChunkChunkFunc func, void * data) 
    405405{ 
    406406  RemixCount n, minn = count; 
    …… 
    440440 */ 
    441441RemixCount 
    442 remix_stream_gain (RemixEnv * env, RemixStream * stream, RemixCount count, RemixPCM gain) 
    443 { 
    444   return remix_stream_chunkfuncify (env, stream, count, _remix_chunk_gain, &gain); 
     442remix_stream_gain (RemixEnv * env, RemixStream * stream, RemixCount count, 
     443                   RemixPCM gain) 
     444{ 
     445  return remix_stream_chunkfuncify (env, stream, count, 
     446                                   _remix_chunk_gain, &gain); 
    445447} 
    446448 
    …… 
    451453 */ 
    452454RemixCount 
    453 remix_stream_copy (RemixEnv * env, RemixStream * src, RemixStream * dest, RemixCount count) 
     455remix_stream_copy (RemixEnv * env, RemixStream * src, RemixStream * dest, 
     456                   RemixCount count) 
    454457{ 
    455458  remix_dprintf ("[remix_stream_copy] (%p -> %p, +%ld)\n", src, dest, count); 
    456459 
    457460  return remix_stream_chunkchunkfuncify (env, src, dest, count, 
    458                                      _remix_chunk_copy, NULL); 
     461                                         _remix_chunk_copy, NULL); 
    459462} 
    460463 
    …… 
    467470RemixCount 
    468471remix_stream_write (RemixEnv * env, RemixStream * stream, RemixCount count, 
    469                 RemixStream * data) 
     472                    RemixStream * data) 
    470473{ 
    471474  remix_dprintf ("[remix_stream_write] (%p -> %p, +%ld)\n", data, stream, count); 
    …… 
    483486 */ 
    484487RemixCount 
    485 remix_stream_mix (RemixEnv * env, RemixStream * src, RemixStream * dest, RemixCount count) 
     488remix_stream_mix (RemixEnv * env, RemixStream * src, RemixStream * dest, 
     489                  RemixCount count) 
    486490{ 
    487491  remix_dprintf ("[remix_stream_mix] (%p -> %p, +%ld)\n", src, dest, count); 
    488492 
    489493  return remix_stream_chunkchunkfuncify (env, src, dest, count, 
    490                                      _remix_chunk_add_inplace, NULL); 
     494                                         _remix_chunk_add_inplace, NULL); 
    491495} 
    492496 
    …… 
    497501 */ 
    498502RemixCount 
    499 remix_stream_mult (RemixEnv * env, RemixStream * src, RemixStream * dest, RemixCount count) 
     503remix_stream_mult (RemixEnv * env, RemixStream * src, RemixStream * dest, 
     504                   RemixCount count) 
    500505{ 
    501506  remix_dprintf ("[remix_stream_mult] (%p -> %p, +%ld)\n", src, dest, count); 
    …… 
    512517RemixCount 
    513518remix_stream_fade (RemixEnv * env, RemixStream * src, RemixStream * dest, 
    514                  RemixCount count) 
     519                   RemixCount count) 
    515520{ 
    516521  remix_dprintf ("[remix_stream_fade] (%p -> %p, +%ld)\n", src, dest, count); 
    517522 
    518523  return remix_stream_chunkchunkfuncify (env, src, dest, count, 
    519                                        _remix_chunk_fade_inplace, NULL); 
     524                                         _remix_chunk_fade_inplace, NULL); 
    520525} 
    521526 
    …… 
    527532RemixCount 
    528533remix_stream_blend (RemixEnv * env, RemixStream * src, RemixStream * blend, 
    529                   RemixStream * dest, RemixCount count) 
     534                    RemixStream * dest, RemixCount count) 
    530535{ 
    531536  remix_dprintf ("[remix_stream_blend] (%p -> (%p) -> %p, +%ld)\n", src, blend, 
    …… 
    533538 
    534539  return remix_stream_chunkchunkchunkfuncify (env, src, blend, dest, count, 
    535                                             _remix_chunk_blend_inplace, NULL); 
     540                                              _remix_chunk_blend_inplace, NULL); 
    536541} 
    537542 
    …… 
    545550RemixCount 
    546551remix_streams_mix (RemixEnv * env, CDList * streams, RemixStream * dest, 
    547                  RemixCount count) 
     552                   RemixCount count) 
    548553{ 
    549554  CDList * sl; 
    …… 
    593598RemixCount 
    594599remix_stream_interleave_2 (RemixEnv * env, RemixStream * stream, 
    595                          int name1, int name2, 
    596                          RemixPCM * dest, RemixCount count) 
     600                           int name1, int name2, 
     601                           RemixPCM * dest, RemixCount count) 
    597602{ 
    598603  RemixChannel * channel1, * channel2; 
    …… 
    622627RemixCount 
    623628remix_stream_deinterleave_2 (RemixEnv * env, RemixStream * stream, 
    624                            int name1, int name2, 
    625                            RemixPCM * src, RemixCount count) 
     629                             int name1, int name2, 
     630                             RemixPCM * src, RemixCount count) 
    626631{ 
    627632  RemixChannel * channel1, * channel2;