annotate stitch/fillable.c @ 0:5242703e91d3 tip

Initial checkin for AIM92 aimR8.2 (last updated May 1997).

/*
    fillable.c
    ==========

    Sources whose native mode of operation is the fill entry point.
    They may be pulled in which case a buffer is allocated.

*/

#include "stitch.h"
#include "source.h"

#ifndef  lint
static char *sccs_id = "@(#)fillable.c	1.2 John Holdsworth (MRC-APU) 11/8/90" ;
#endif

#if 0
#define DEBUG 1
#endif

Source SharingSource( source1, source2 )
struct _fillable_source *source1, *source2 ;
{
    DeleteBuffer( source1->buffer ) ;

    source1->buffer = SharedBuffer( source2->buffer ) ;

    return ( (Source) source1 ) ;
}

/* converter of pull command to fill commands */

static Pointer pullFromFillable( source, bytes )
struct _fillable_source *source ;
ByteCount *bytes ;
{
#if DEBUG
    printf( "buffering pulling from passive \"%s\", %d bytes\n", SourceName( source ), *bytes ) ;
#endif
#if 00
    if( source->bsize < *bytes ) {

	if( source->bsize != 0 )
	    Delete( source->buffer ) ;

	source->buffer = Allocate( *bytes, "fillable.c for source buffer" ) ;

	source->bsize  = *bytes ;
    }
#endif
    return ( source->parent.fill( source, bytes, SizedBufferPointer( SourceBuffer( source ), *bytes ) ) ) ;
}

/* constructor for all pullable sources */

Source setFillableSource( source, filler, name )
struct _fillable_source *source ;
Pointer (*filler)() ;
char *name ;
{
    source->buffer = NewBuffer( "pulling" ) ;

    return ( SetSource( source, pullFromFillable, filler, nonRoller, name ) ) ;
}

Pointer deleteFillableSource( source )
struct _fillable_source *source ;
{
    DeleteBuffer( source->buffer ) ;

    return ( DeleteSource( source ) ) ;
}


/* derived fillable source */

typedef struct {
 struct _fillable_source parent ;
 Pointer data, end, ptr ;
 } *RepeatingSource ;

static Pointer repeating_callback( source, bytes, buffer )
RepeatingSource source ;
ByteCount *bytes ;
Pointer buffer ;
{
    register int last = *bytes == 0 ;
    register Pointer bptr = buffer ;
    register Pointer bend = buffer + *bytes ;
    register ByteCount segment ;

    if( !last ) {

	while( bptr < bend ) {

	    segment = source->end - source->ptr ;
	    if( segment > bend - bptr )
		segment = bend - bptr ;

	    CopyArray( (char *) source->ptr, (char *) bptr, segment ) ;

	    source->ptr += segment ;
	    bptr        += segment ;

	    if( source->ptr == source->end )
		source->ptr = source->data ;
	}

	return ( buffer ) ;
    }
    else
	return ( DeleteFillableSource( source ) ) ;
}

Source newRepeatingSource( data, segment )
Pointer data ;
ByteCount segment ;
{
    DeclareNew( RepeatingSource, source ) ;

    source->data = data ;
    source->end  = data + segment ;

    source->ptr  = source->data ;

    return ( SetFillableSource( source, repeating_callback, "fillable.c repeating" ) ) ;
}

typedef struct {
 struct _fillable_source parent ;
 Source input ; ByteCount segment ;
 } *SegmentingSource ;

static Pointer segmenting_callback( source, bytes, buffer )
SegmentingSource source ;
ByteCount *bytes ;
Pointer buffer ;
{
    register int last = *bytes == 0 ;
    Pointer bptr = buffer ;
    ByteCount segment ;

    do {

	segment = source->segment ;

	if( segment > buffer + *bytes - bptr )
	    segment = buffer + *bytes - bptr ;

	(void) FillSome( source->input, &segment, bptr ) ;

	bptr += segment ;

    } while ( bptr < buffer + *bytes ) ;

    if( !last )
	return ( buffer  ) ;
    else
	return ( DeleteFillableSource( source ) ) ;
}

Source newSegmentingSource( input, segment )
Source input ;
ByteCount segment ;
{
    DeclareNew( SegmentingSource, source ) ;

    source->input = input ;

    source->segment = segment ;

    return ( SetFillableSource( source, segmenting_callback, "segmenting" ) ) ;
}



/* higher level methods to sources */


typedef struct _callback_source {
 struct _fillable_source parent ;
 Pointer state ;
 void (*callback)(), (*close)() ;
 } *CallbackSource ;

Source setCallbackSource( source, filler, state, callback, close, name )
CallbackSource source ;
Pointer (*filler)() ;
Pointer state ;
void (*callback)(), (*close)() ;
char *name ;
{
    source->state    = state    ;
    source->callback = callback ;
    source->close    = close    ;

    return ( SetFillableSource( source, filler, name ) ) ;
}

Source newCallbackSource( filler, state, callback, close, name )
Pointer (*filler)() ;
Pointer state ;
void (*callback)(), (*close)() ;
char *name ;
{
    return ( setCallbackSource( New( CallbackSource ), filler, state, callback, close, name ) ) ;
}

static Pointer externalFiller( source, bytes, buffer )
CallbackSource source ;
ByteCount *bytes ;
Pointer buffer ;
{
    register int last = *bytes == 0 ;

    source->callback( source->state, bytes, buffer, buffer+*bytes ) ;

    if( !last )
	return ( buffer ) ;
    else {
	if( source->close != (void ( * )()) 0 )
	    source->close( source->state ) ;

	return ( DeleteFillableSource( source ) ) ;
    }
}

Source newExternalSource( state, callback, close, name )
Pointer state ;
void (*callback)(), (*close)() ;
char *name ;
{
    return ( newCallbackSource( externalFiller, state, callback, close, name ) ) ;
}

typedef struct _through_source {
 struct _callback_source parent ;
 Source input ;
 } *ThroughSource ;

static Source setThroughSource( source, filler, state, callback, close, input, name )
ThroughSource source ;
Pointer (*filler)() ;
Pointer state ;
void (*callback)(), (*close)() ;
Source input ;
char *name ;
{
    source->input = input ;

    return ( setCallbackSource( (CallbackSource) source, filler, state, callback, close, name ) ) ;
}

Source newThroughSource( filler, state, callback, close, input, name )
Pointer (*filler)(), state ;
void (*callback)(), (*close)() ;
Source input ;
char *name ;
{
    return ( setThroughSource( New( ThroughSource ), filler, state, callback, close, input, name ) ) ;
}


static Pointer processingFiller( source, bytes, buffer )
ThroughSource source ;
ByteCount *bytes ;
Pointer buffer ;
{
    register int last = *bytes == 0 ;

    source->parent.callback( source->parent.state, bytes, buffer, buffer+*bytes, PullSome( source->input, bytes ) ) ;

    if( !last )
	return ( buffer ) ;
    else {
	if( source->parent.close != (void ( * )()) 0 )
	    source->parent.close( source->parent.state ) ;

	return ( DeleteFillableSource( &source->parent ) ) ;
    }
}

Source newProcessingSource( state, callback, close, input, name )
Pointer state ;
void (*callback)(), (*close)() ;
Source input ;
char *name ;
{
    return ( newThroughSource( processingFiller, state, callback, close, input, name ) ) ;
}

Source newSimpleProcessingSource( callback, input, name )
void (*callback)() ;
Source input ;
char *name ;
{
    return ( NewProcessingSource( (Pointer) 0, callback, (void ( * )()) 0, input, name ) ) ;
}

typedef struct {
    struct _fillable_source parent ;
    Pointer *states ;
    int (*callback)() ;
    void (*close)() ;
    int channels ;
    Source input ;
} *MultiplexedSource ;

static Pointer multiplexed_callback( source, bytes, buffer )
MultiplexedSource source ;
ByteCount *bytes ;
Pointer buffer ;
{
    register int last = *bytes == 0 ;
    Pointer iptr = PullSome( source->input, bytes ) ;
    Pointer optr = buffer ;
    Pointer end = buffer + *bytes ;
    ByteCount data_size ;
    int channel ;

    for( channel=0 ; channel<source->channels ; channel++ ) {
	data_size = source->callback( source->states[channel], optr, end, iptr, source->channels ) ;
	iptr += data_size ;
	optr += data_size ;
    }

    if( !last )
	return ( buffer ) ;
    else {
	if( source->close != (void ( * )()) 0 )
	    for( channel=0 ; channel<source->channels ; channel++ )
		source->close( source->states[channel] ) ;

	Delete( source->states ) ;

	return ( DeleteFillableSource( source ) ) ;
    }
}

Source newMultiplexedSource( states, callback, close, channels, input, name )
Pointer *states ;
int (*callback)() ;
void (*close)() ;
int channels ;
Source input ;
char *name ;
{
    DeclareNew( MultiplexedSource, source ) ;

    source->states   = states   ;
    source->callback = callback ;
    source->close    = close    ;
    source->channels = channels ;

    source->input    = input    ;

    return ( SetFillableSource( source, multiplexed_callback, name ) ) ;
}

typedef struct _merging_source {
 struct _callback_source parent ; Source *inputs ;
 } *MergingSource ;

static Pointer mergingFiller( source, bytes, buffer )
MergingSource source ;
ByteCount *bytes ;
Pointer buffer ;
{
    register int last = *bytes == 0 ;
    Pointer input1, input2 ;
    int n ;

    input1 = PullSome( source->inputs[0], bytes ) ;

    for( n=1 ; _SPTR( source->inputs[n] ) != (struct _source *) 0 ; n++ ) {

	input2 = PullSome( source->inputs[n], bytes ) ;

	source->parent.callback( source->parent.state, bytes, buffer, buffer+*bytes, input1, input2 ) ;

	input1 = buffer ;
    }

    if( !last )
	return ( buffer ) ;
    else {
	Delete( source->inputs  ) ;

	return ( DeleteFillableSource( &source->parent ) ) ;
    }
}

Source newMergingSource( state, callback, close, inputs, name )
Pointer state ;
void (*callback)(), (*close)() ;
Source *inputs ;
char *name ;
{
    DeclareNew( MergingSource, source ) ;

    source->inputs = inputs ;

    return ( setCallbackSource( (CallbackSource) source, mergingFiller, state, callback, close, name ) ) ;
}