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;
}
