Exemplo n.º 1
0
static void
callback_common(unsigned num,rgba *pixels)
{
  if( flatspec.transmap_filename ) {
    if( flatspec.partial_transparency_mode == ALLOW_PARTIAL_TRANSPARENCY ) {
      unsigned i ;
      if( transfile == NULL ) start_writing(&transfile,5);
      for( i=0; i < num; i++ )
        putc( ALPHA(pixels[i]), transfile );
    } else {
      if( transfile == NULL ) {
        start_writing(&transfile,4);
      }
      /* Partial transparency should have been caught in the flattener,
       * so just extract a single byte.
       */
      put_pbm_row(transfile,num,pixels,(rgba)1 << ALPHA_SHIFT);
    }
  } else if( ALPHA(flatspec.default_pixel) < 128 ) {
    unsigned i ;
    for( i=0; i < num; i++ )
      if( !FULLALPHA(pixels[i]) )
        FatalGeneric(100,_("Transparency found, but -a option not given"));
  }
  xcffree(pixels) ;
}
Exemplo n.º 2
0
static void read_completed(BOOL resultOk, DWORD length,
   SocketState* socketState, WSAOVERLAPPED* ovl)
{
   if (resultOk)
   {
      if (length > 0)
      {
         printf("* read operation completed, %d bytes read\n", length);

         // starts another write
         socketState->length = length;
         start_writing(socketState, ovl);
      }
      else // length == 0
      {
         printf("* connection closed by client\n");
         destroy_connection(socketState, ovl);
      }
   }
   else // !resultOk, assumes connection was reset
   {  int err = GetLastError();
      printf("* error %d in recv, assuming connection was reset by client\n",
         err);
      destroy_connection(socketState, ovl);
   }
}
Exemplo n.º 3
0
int update_header_segment(unsigned segment, byte * buffer)
{
    TRACE_FUN(5, "update_header_segment");
    int result = 0;
    int status;

    if (buffer == NULL) {
        TRACE(5, "no input buffer specified");
        buffer = deblock_buffer;
        result = read_segment(used_header_segment, buffer, &status, 0);
        if (bad_sector_map_changed) {
            store_bad_sector_map(buffer);
        }
        if (failed_sector_log_changed) {
            update_failed_sector_log(buffer);
        }
    }
    if (result >= 0 && GET4(buffer, 0) != 0xaa55aa55) {
        TRACE(1, "wrong header signature found, aborting");
        result = -EIO;
    }
    if (result >= 0) {
        result = _write_segment(segment, buffer, 0);
        if (result >= 0 && runner_status == idle) {
            /*  Force flush for single segment instead of relying on
             *  flush in read_segment for multiple segments.
             */
            result = start_writing(WRITE_SINGLE);
            if (result >= 0 && ftape_state == writing) {
                result = loop_until_writes_done();
                prevent_flush();
            }
        }
#ifdef VERIFY_HEADERS
        if (result >= 0) {	/* read back and verify */
            result = read_segment(segment, scratch_buffer, &status, 0);
            /*  Should retry if soft error during read !
             *  TO BE IMPLEMENTED
             */
            if (result >= 0) {
                if (memcmp(buffer, scratch_buffer, sizeof(buffer)) == 0) {
                    result = 0;	/* verified */
                    TRACE(5, "verified");
                } else {
                    result = -EIO;	/* verify failed */
                    TRACE(5, "verify failed");
                }
            }
        }
#endif
    }
    TRACE_EXIT;
    return result;
}
Exemplo n.º 4
0
static void
pbm_callback(unsigned num,rgba *pixels)
{
  if( outfile == NULL ) start_writing(&outfile,4);
  if( !put_pbm_row(outfile,num,pixels,
                   ((rgba)255 << RED_SHIFT) +
                   ((rgba)255 << GREEN_SHIFT) +
                   ((rgba)255 << BLUE_SHIFT)) )
    FatalGeneric(103,_("Monochrome output selected, but not all pixels "
                       "are black or white"));
  callback_common(num,pixels);
}
Exemplo n.º 5
0
static void
ppm_callback(unsigned num,rgba *pixels)
{
  unsigned i ;
  if( outfile == NULL ) start_writing(&outfile,6);
  for( i=0; i < num; i++ ) {
    putc( (pixels[i] >> RED_SHIFT) & 0xFF   , outfile );
    putc( (pixels[i] >> GREEN_SHIFT) & 0xFF , outfile );
    putc( (pixels[i] >> BLUE_SHIFT) & 0xFF  , outfile );
  }
  callback_common(num,pixels);
}
Exemplo n.º 6
0
int loop_until_writes_done(void)
{
    TRACE_FUN(5, "loop_until_writes_done");
    int i;
    int result = 0;

    /*
     *  Wait until all data is actually written to tape.
     */
    while (ftape_state == writing && buffer[head].status != done) {
        TRACEx2(7, "tail: %d, head: %d", tail, head);
        for (i = 0; i < NR_BUFFERS; ++i) {
            TRACEx3(8, "buffer[ %d] segment_id: %d, status: %d",
                    i, buffer[i].segment_id, buffer[i].status);
        }
        result = fdc_interrupt_wait(5 * SECOND);
        if (result < 0) {
            TRACE(1, "fdc_interrupt_wait failed");
            last_write_failed = 1;
            break;
        }
        if (buffer[head].status == error) {
            /* Allow escape from loop when signaled !
             */
            if (current->signal & _DONT_BLOCK) {
                TRACE(2, "interrupted by signal");
                TRACE_EXIT;
                result = -EINTR;	/* is this the right return value ? */
                break;
            }
            if (buffer[head].hard_error_map != 0) {
                /*  Implement hard write error recovery here
                 */
            }
            buffer[head].status = waiting;	/* retry this one */
            if (runner_status == aborting) {
                ftape_dumb_stop();
                runner_status = idle;
            }
            if (runner_status != idle) {
                TRACE(1, "unexpected state: runner_status != idle");
                result = -EIO;
                break;
            }
            start_writing(WRITE_MULTI);
        }
        TRACE(5, "looping until writes done");
        result = 0;	/* normal exit status */
    }
    TRACE_EXIT;
    return result;
}
Exemplo n.º 7
0
static void
pgm_callback(unsigned num,rgba *pixels)
{
  unsigned i ;
  if( outfile == NULL ) start_writing(&outfile,5);
  for( i=0; i < num; i++ ) {
    int gray = degrayPixel(pixels[i]) ;
    if( gray == -1 )
      FatalGeneric(103,
                   _("Grayscale output selected, but colored pixel(s) found"));
    putc( gray, outfile );
  }
  callback_common(num,pixels);
}
Exemplo n.º 8
0
int ftape_flush_buffers(void)
{
    TRACE_FUN(5, "ftape_flush_buffers");
    int result;
    int pad_count;
    int data_remaining;
    static int active = 0;

    if (active) {
        TRACE(5, "nested call, abort");
        TRACE_EXIT;
        return 0;
    }
    active = 1;
    TRACEi(5, "entered, ftape_state =", ftape_state);
    if (ftape_state != writing && !need_flush) {
        active = 0;
        TRACE(5, "no need for flush");
        TRACE_EXIT;
        return 0;
    }
    data_remaining = buf_pos_wr;
    buf_pos_wr = 0;		/* prevent further writes if this fails */
    TRACE(5, "flushing write buffers");
    if (last_write_failed) {
        ftape_zap_write_buffers();
        active = 0;
        TRACE_EXIT;
        return write_protected ? -EROFS : -EIO;
    }
    /*
     *    If there is any data not written to tape yet, append zero's
     *    up to the end of the sector. Then write the segment(s) to tape.
     */
    if (data_remaining > 0) {
        int written;

        do {
            TRACEi(4, "remaining in buffer:", data_remaining);
            pad_count = sizeof(deblock_buffer) - data_remaining;
            TRACEi(7, "flush, padding count:", pad_count);
            memset(deblock_buffer + data_remaining, 0, pad_count);	/* pad buffer */
            result = _write_segment(ftape_seg_pos, deblock_buffer, 1);
            if (result < 0) {
                if (result != -ENOSPC) {
                    last_write_failed = 1;
                }
                active = 0;
                TRACE_EXIT;
                return result;
            }
            written = result;
            clear_eof_mark_if_set(ftape_seg_pos, written);
            TRACEi(7, "flush, moved out buffer:", written);
            if (written > 0) {
                data_remaining -= written;
                if (data_remaining > 0) {
                    /*  Need another segment for remaining data, move the remainder
                     *  to the beginning of the buffer
                     */
                    memmove(deblock_buffer, deblock_buffer + written, data_remaining);
                }
            }
            ++ftape_seg_pos;
        } while (data_remaining > 0);
        /*  Data written to last segment == data_remaining + written
         *  value is in range [1..29K].
         */
        TRACEx2(4, "last write: %d, netto pad-count: %d",
                data_remaining + written, -data_remaining);
        if (-1024 < data_remaining && data_remaining <= 0) {
            /*  Last sector of segment was used for data, so put eof mark
             *  in next segment and position at second file mark.
             */
            if (ftape_weof(2, ftape_seg_pos, 1) >= 0) {
                ++ftape_seg_pos;	/* position between file marks */
            }
        } else {
            /*  Put eof mark in previous segment after data and position
             *  at second file mark.
             */
            ftape_weof(2, ftape_seg_pos - 1, 1 +
                       ((SECTOR_SIZE - 1 + result + data_remaining) / SECTOR_SIZE));
        }
    } else {
        TRACE(7, "deblock_buffer empty");
        if (ftape_weof(2, ftape_seg_pos, 1) >= 0) {
            ++ftape_seg_pos;	/* position between file marks */
        }
        start_writing(WRITE_MULTI);
    }
    TRACE(7, "waiting");
    result = loop_until_writes_done();
    if (result < 0) {
        TRACE(1, "flush buffers failed");
    }
    ftape_state = idle;
    last_write_failed = 0;
    need_flush = 0;
    active = 0;
    TRACE_EXIT;
    return result;
}
Exemplo n.º 9
0
/*      Write given segment from buffer at address onto tape.
 */
int write_segment(unsigned segment_id, byte * address, int flushing)
{
    TRACE_FUN(5, "write_segment");
    int result = 0;
    int bytes_written = 0;

    TRACEi(5, "segment_id =", segment_id);
    if (ftape_state != writing) {
        if (ftape_state == reading) {
            TRACE(5, "calling ftape_abort_operation");
            result = ftape_abort_operation();
            if (result < 0) {
                TRACE(1, "ftape_abort_operation failed");
            }
        }
        ftape_zap_read_buffers();
        ftape_zap_write_buffers();
        ftape_state = writing;
    }
    /*    if all buffers full we'll have to wait...
     */
    wait_segment(writing);
    if (buffer[tail].status == error) {
        /*  setup for a retry
         */
        buffer[tail].status = waiting;
        bytes_written = -EAGAIN;	/* force retry */
        if (buffer[tail].hard_error_map != 0) {
            TRACEx1(1, "warning: %d hard error(s) in written segment",
                    count_ones(buffer[tail].hard_error_map));
            TRACEx1(4, "hard_error_map = 0x%08lx", buffer[tail].hard_error_map);
            /*  Implement hard write error recovery here
             */
        }
    } else if (buffer[tail].status == done) {
        history.defects += count_ones(buffer[tail].hard_error_map);
    } else {
        TRACE(1, "wait for empty segment failed");
        result = -EIO;
    }
    /*    If just passed last segment on tape: wait for BOT or EOT mark.
     */
    if (result >= 0 && runner_status == logical_eot) {
        int status;

        result = ftape_ready_wait(timeout.seek, &status);
        if (result < 0 || (status & (QIC_STATUS_AT_BOT | QIC_STATUS_AT_EOT)) == 0) {
            TRACE(1, "eot/bot not reached");
        } else {
            runner_status = end_of_tape;
        }
    }
    /*    should runner stop ?
     */
    if (result >= 0 &&
            (runner_status == aborting || runner_status == buffer_underrun ||
             runner_status == end_of_tape)) {
        if (runner_status != end_of_tape) {
            result = ftape_dumb_stop();
        }
        if (result >= 0) {
            if (runner_status == aborting) {
                if (buffer[head].status == writing) {
                    buffer[head].status = done;	/* ????? */
                }
            }
            runner_status = idle;	/* aborted ? */
        }
    }
    /*  Don't start tape if runner idle and segment empty.
     */
    if (result >= 0 && !(runner_status == idle &&
                         get_bad_sector_entry(segment_id) == EMPTY_SEGMENT)) {
        if (buffer[tail].status == done) {
            /*    now at least one buffer is empty, fill it with our data.
             *    skip bad sectors and generate ecc.
             *    copy_and_gen_ecc return nr of bytes written,
             *    range 0..29 Kb inclusive !
             */
            result = copy_and_gen_ecc(buffer[tail].address, address,
                                      get_bad_sector_entry(segment_id));
            if (result >= 0) {
                bytes_written = result;
                buffer[tail].segment_id = segment_id;
                buffer[tail].status = waiting;
                next_buffer(&tail);
            }
        }
        /*    Start tape only if all buffers full or flush mode.
         *    This will give higher probability of streaming.
         */
        if (result >= 0 && runner_status != running &&
                ((head == tail && buffer[tail].status == waiting) || flushing)) {
            result = start_writing(WRITE_MULTI);
        }
    }
    TRACE_EXIT;
    return (result < 0) ? result : bytes_written;
}