static int cbs_jpeg_write_segment(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc) { int err; if (unit->type >= JPEG_MARKER_SOF0 && unit->type <= JPEG_MARKER_SOF3) { err = cbs_jpeg_write_frame_header(ctx, pbc, unit->content); } else if (unit->type >= JPEG_MARKER_APPN && unit->type <= JPEG_MARKER_APPN + 15) { err = cbs_jpeg_write_application_data(ctx, pbc, unit->content); } else { switch (unit->type) { #define SEGMENT(marker, func) \ case JPEG_MARKER_ ## marker: \ err = cbs_jpeg_write_ ## func(ctx, pbc, unit->content); \ break; SEGMENT(DQT, dqt); SEGMENT(DHT, dht); SEGMENT(COM, comment); default: return AVERROR_PATCHWELCOME; } } return err; }
float AverageSpectrumSamples(const float *lambda, const float *vals, int n, float lambdaStart, float lambdaEnd) { for (int i = 0; i < n-1; ++i) Assert(lambda[i+1] > lambda[i]); Assert(lambdaStart < lambdaEnd); // Handle cases with out-of-bounds range or single sample only if (lambdaEnd <= lambda[0]) return vals[0]; if (lambdaStart >= lambda[n-1]) return vals[n-1]; if (n == 1) return vals[0]; float sum = 0.f; // Add contributions of constant segments before/after samples if (lambdaStart < lambda[0]) sum += vals[0] * (lambda[0] - lambdaStart); if (lambdaEnd > lambda[n-1]) sum += vals[n-1] * (lambdaEnd - lambda[n-1]); // Advance to first relevant wavelength segment int i = 0; while (lambdaStart > lambda[i+1]) ++i; Assert(i+1 < n); // Loop over wavelength sample segments and add contributions #define INTERP(w, i) Lerp(((w)-lambda[i]) / \ (lambda[(i)+1]-lambda[i]), \ vals[i], vals[(i)+1]) #define SEGMENT(wl0, wl1, i) (0.5f * (INTERP(wl0, i) + INTERP(wl1, i))) for (; i+1 < n && lambdaEnd >= lambda[i]; ++i) { float segStart = max(lambdaStart, lambda[i]); float segEnd = min(lambdaEnd, lambda[i+1]); sum += SEGMENT(segStart, segEnd, i) * (segEnd - segStart); } #undef INTERP #undef SEGMENT return sum / (lambdaEnd - lambdaStart); }
int install_undi_irq_handler ( irq_t irq, segoff_t entrypointsp ) { segoff_t undi_irq_handler_segoff = SEGOFF(undi_irq_handler); if ( undi_irq_installed_on != IRQ_NONE ) { DBG ( "Can install undi IRQ handler only once\n" ); return 0; } if ( SEGMENT(undi_irq_handler) > 0xffff ) { DBG ( "Trivial IRQ handler not in base memory\n" ); return 0; } DBG ( "Installing undi IRQ handler on IRQ %d\n", irq ); *pxenv_undi_entrypointsp = entrypointsp; *pxenv_undi_irq = irq; if ( ! install_irq_handler ( irq, &undi_irq_handler_segoff, undi_irq_chain, undi_irq_chain_to ) ) return 0; undi_irq_installed_on = irq; DBG ( "Disabling undi IRQ %d\n", irq ); disable_irq ( irq ); *undi_irq_trigger_count = 0; undi_irq_previous_trigger_count = 0; DBG ( "UNDI IRQ handler installed successfully\n" ); return 1; }
/* * to use this function you should first make sure that * there is room for `count' bits in the scanline * * A general-purpose (but not very efficient) function to paint `n' pixels * on a bitmap, starting at position (x, y) would be: * * bitmap_paint_bits(__bm_unit_ptr(bitmap, x, y), x % BITMAP_BITS, n) * */ void bitmap_paint_bits(BmUnit *ptr, int n, int count) { /* paint the head */ if(n + count > BITMAP_BITS) { *ptr |= SEGMENT(BITMAP_BITS - n, n); count -= BITMAP_BITS - n; ptr++; } else { *ptr |= SEGMENT(count, n); return; } /* paint the middle */ for(; count >= BITMAP_BITS; count -= BITMAP_BITS) *ptr++ = bit_masks[BITMAP_BITS]; /* paint the tail */ if(count > 0) *ptr |= SEGMENT(count, 0); }
int biosread(int dev, int cyl, int head, int sec, int num) { int i; bb.intno = 0x13; sec += 1; // sector numbers start at 1. for (i=0;;) { bb.ecx.r.h = cyl; bb.ecx.r.l = ((cyl & 0x300) >> 2) | (sec & 0x3F); bb.edx.r.h = head; bb.edx.r.l = dev; bb.eax.r.l = num; bb.ebx.rr = OFFSET(ptov(BIOS_ADDR)); bb.es = SEGMENT(ptov(BIOS_ADDR)); bb.eax.r.h = 0x02; bios(&bb); // In case of a successful call, make sure we set AH (return code) to zero. if (bb.flags.cf == 0) { bb.eax.r.h = 0; } // Now we can really check for the return code (AH) value. if ((bb.eax.r.h == 0x00) || (i++ >= 5)) { break; } // Reset disk subsystem and try again. bb.eax.r.h = 0x00; bios(&bb); } return bb.eax.r.h; }
// Takes a string representing an Address // It can be of the following forms: // 1) seg:off (hex only for segment and offset) // 2) 0xAB, 0XAB (hex) // 3) ABh, ABH (hex) // 3) 171 (decimal assumed) void InterpretAddress(char *addrString, Address *addr) { int i, len; bool isColon; char *segmentStr, *offsetStr; isColon = false; // Determin string length for(len = 0; addrString[len] != '\0'; len++); // Check for HEX segment offset form 0000:0000 for(i = 0; i < len; i++) { if(addrString[i] == ':') { isColon = true; addrString[i] = '\0'; // Null terminate segment segmentStr = &addrString[0]; offsetStr = &addrString[i+1]; } } if(isColon) { // Of form seg:off. Get the two and calculate physical address. //addr->segment = XtoI(segmentStr); //addr->offset = XtoI(offsetStr); sscanf(segmentStr, "%x", &(addr->segment)); sscanf(offsetStr, "%x", &(addr->offset)); addr->physical = PHYSICAL_ADDR(addr->segment, addr->offset); } else { // Single number. Get it and calculate segment and offset. addr->physical = InterpretNumber(addrString); addr->segment = SEGMENT(addr->physical); addr->offset = OFFSET(addr->physical); } }
int ebiosread(int dev, unsigned long long sec, int count) { int i; static struct { unsigned char size; unsigned char reserved; unsigned char numblocks; unsigned char reserved2; unsigned short bufferOffset; unsigned short bufferSegment; unsigned long long startblock; } addrpacket __attribute__((aligned(16))) = {0}; addrpacket.size = sizeof(addrpacket); for (i = 0; ;) { bb.intno = 0x13; bb.eax.r.h = 0x42; bb.edx.r.l = dev; bb.esi.rr = NORMALIZED_OFFSET((unsigned)&addrpacket); bb.ds = NORMALIZED_SEGMENT((unsigned)&addrpacket); addrpacket.reserved = addrpacket.reserved2 = 0; addrpacket.numblocks = count; addrpacket.bufferOffset = OFFSET(ptov(BIOS_ADDR)); addrpacket.bufferSegment = SEGMENT(ptov(BIOS_ADDR)); addrpacket.startblock = sec; bios(&bb); // In case of a successful call, make sure we set AH (return code) to zero. if (bb.flags.cf == 0) { bb.eax.r.h = 0; } // Now we can really check for the return code (AH) value. if ((bb.eax.r.h == 0x00) || (i++ >= 5)) { break; } // Reset disk subsystem and try again. bb.eax.r.h = 0x00; bios(&bb); } return bb.eax.r.h; } //============================================================================== void putc(int ch) { bb.intno = 0x10; bb.ebx.r.h = 0x00; /* background black */ bb.ebx.r.l = 0x0F; /* foreground white */ bb.eax.r.h = 0x0e; bb.eax.r.l = ch; bios(&bb); }
static int cbs_jpeg_read_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit) { GetBitContext gbc; int err; err = init_get_bits(&gbc, unit->data, 8 * unit->data_size); if (err < 0) return err; if (unit->type >= JPEG_MARKER_SOF0 && unit->type <= JPEG_MARKER_SOF3) { err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(JPEGRawFrameHeader), NULL); if (err < 0) return err; err = cbs_jpeg_read_frame_header(ctx, &gbc, unit->content); if (err < 0) return err; } else if (unit->type >= JPEG_MARKER_APPN && unit->type <= JPEG_MARKER_APPN + 15) { err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(JPEGRawApplicationData), &cbs_jpeg_free_application_data); if (err < 0) return err; err = cbs_jpeg_read_application_data(ctx, &gbc, unit->content); if (err < 0) return err; } else if (unit->type == JPEG_MARKER_SOS) { JPEGRawScan *scan; int pos; err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(JPEGRawScan), &cbs_jpeg_free_scan); if (err < 0) return err; scan = unit->content; err = cbs_jpeg_read_scan_header(ctx, &gbc, &scan->header); if (err < 0) return err; pos = get_bits_count(&gbc); av_assert0(pos % 8 == 0); if (pos > 0) { scan->data_size = unit->data_size - pos / 8; scan->data_ref = av_buffer_ref(unit->data_ref); if (!scan->data_ref) return AVERROR(ENOMEM); scan->data = unit->data + pos / 8; } } else { switch (unit->type) { #define SEGMENT(marker, type, func, free) \ case JPEG_MARKER_ ## marker: \ { \ err = ff_cbs_alloc_unit_content(ctx, unit, \ sizeof(type), free); \ if (err < 0) \ return err; \ err = cbs_jpeg_read_ ## func(ctx, &gbc, unit->content); \ if (err < 0) \ return err; \ } \ break SEGMENT(DQT, JPEGRawQuantisationTableSpecification, dqt, NULL); SEGMENT(DHT, JPEGRawHuffmanTableSpecification, dht, NULL); SEGMENT(COM, JPEGRawComment, comment, &cbs_jpeg_free_comment); #undef SEGMENT default: return AVERROR(ENOSYS); } } return 0; }