Sakurai/pdf.js
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #498 from kkujala/master

Browse Source 
Align switch cases properly.
This commit is contained in:
vingtetun 2011-09-19 14:28:07 -07:00
commit a0c58a5b73
1 changed files with 360 additions and 366 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

726
pdf.js
View File

@ -799,59 +799,58 @@ var PredictorStream = (function() {
prevRow = currentRow; prevRow = currentRow;
switch (predictor) { switch (predictor) {
case 0: case 0:
break; break;
case 1: case 1:
for (var i = 0; i < pixBytes; ++i) for (var i = 0; i < pixBytes; ++i)
currentRow[i] = rawBytes[i]; currentRow[i] = rawBytes[i];
for (; i < rowBytes; ++i) for (; i < rowBytes; ++i)
currentRow[i] = (currentRow[i - pixBytes] + rawBytes[i]) & 0xFF; currentRow[i] = (currentRow[i - pixBytes] + rawBytes[i]) & 0xFF;
break; break;
case 2: case 2:
for (var i = 0; i < rowBytes; ++i) for (var i = 0; i < rowBytes; ++i)
currentRow[i] = (prevRow[i] + rawBytes[i]) & 0xFF; currentRow[i] = (prevRow[i] + rawBytes[i]) & 0xFF;
break; break;
case 3: case 3:
for (var i = 0; i < pixBytes; ++i) for (var i = 0; i < pixBytes; ++i)
currentRow[i] = (prevRow[i] >> 1) + rawBytes[i]; currentRow[i] = (prevRow[i] >> 1) + rawBytes[i];
for (; i < rowBytes; ++i) { for (; i < rowBytes; ++i) {
currentRow[i] = (((prevRow[i] + currentRow[i - pixBytes]) >> 1) + currentRow[i] = (((prevRow[i] + currentRow[i - pixBytes]) >> 1) +
rawBytes[i]) & 0xFF; rawBytes[i]) & 0xFF;
} }
break; break;
case 4: case 4:
// we need to save the up left pixels values. the simplest way // we need to save the up left pixels values. the simplest way
// is to create a new buffer // is to create a new buffer
for (var i = 0; i < pixBytes; ++i) for (var i = 0; i < pixBytes; ++i)
currentRow[i] = rawBytes[i]; currentRow[i] = rawBytes[i];
for (; i < rowBytes; ++i) { for (; i < rowBytes; ++i) {
var up = prevRow[i]; var up = prevRow[i];
var upLeft = prevRow[i - pixBytes]; var upLeft = prevRow[i - pixBytes];
var left = currentRow[i - pixBytes]; var left = currentRow[i - pixBytes];
var p = left + up - upLeft; var p = left + up - upLeft;
var pa = p - left; var pa = p - left;
if (pa < 0) if (pa < 0)
pa = -pa; pa = -pa;
var pb = p - up; var pb = p - up;
if (pb < 0) if (pb < 0)
pb = -pb; pb = -pb;
var pc = p - upLeft; var pc = p - upLeft;
if (pc < 0) if (pc < 0)
pc = -pc; pc = -pc;
var c = rawBytes[i]; var c = rawBytes[i];
if (pa <= pb && pa <= pc) if (pa <= pb && pa <= pc)
currentRow[i] = left + c; currentRow[i] = left + c;
else if (pb <= pc) else if (pb <= pc)
currentRow[i] = up + c; currentRow[i] = up + c;
else else
currentRow[i] = upLeft + c; currentRow[i] = upLeft + c;
} }
break; break;
default: default:
error('Unsupported predictor: ' + predictor); error('Unsupported predictor: ' + predictor);
break;
} }
this.bufferLength += rowBytes; this.bufferLength += rowBytes;
}; };
@ -1695,129 +1694,128 @@ var CCITTFaxStream = (function() {
while (codingLine[this.codingPos] < columns) { while (codingLine[this.codingPos] < columns) {
code1 = this.getTwoDimCode(); code1 = this.getTwoDimCode();
switch (code1) { switch (code1) {
case twoDimPass: case twoDimPass:
this.addPixels(refLine[refPos + 1], blackPixels); this.addPixels(refLine[refPos + 1], blackPixels);
if (refLine[refPos + 1] < columns) if (refLine[refPos + 1] < columns)
refPos += 2;
break;
case twoDimHoriz:
code1 = code2 = 0;
if (blackPixels) {
do {
code1 += (code3 = this.getBlackCode());
} while (code3 >= 64);
do {
code2 += (code3 = this.getWhiteCode());
} while (code3 >= 64);
} else {
do {
code1 += (code3 = this.getWhiteCode());
} while (code3 >= 64);
do {
code2 += (code3 = this.getBlackCode());
} while (code3 >= 64);
}
this.addPixels(codingLine[this.codingPos] +
code1, blackPixels);
if (codingLine[this.codingPos] < columns) {
this.addPixels(codingLine[this.codingPos] + code2,
blackPixels ^ 1);
}
while (refLine[refPos] <= codingLine[this.codingPos] &&
refLine[refPos] < columns) {
refPos += 2;
}
break;
case twoDimVertR3:
this.addPixels(refLine[refPos] + 3, blackPixels);
blackPixels ^= 1;
if (codingLine[this.codingPos] < columns) {
++refPos;
while (refLine[refPos] <= codingLine[this.codingPos] &&
refLine[refPos] < columns)
refPos += 2; refPos += 2;
} break;
break; case twoDimHoriz:
case twoDimVertR2: code1 = code2 = 0;
this.addPixels(refLine[refPos] + 2, blackPixels); if (blackPixels) {
blackPixels ^= 1; do {
if (codingLine[this.codingPos] < columns) { code1 += (code3 = this.getBlackCode());
++refPos; } while (code3 >= 64);
do {
code2 += (code3 = this.getWhiteCode());
} while (code3 >= 64);
} else {
do {
code1 += (code3 = this.getWhiteCode());
} while (code3 >= 64);
do {
code2 += (code3 = this.getBlackCode());
} while (code3 >= 64);
}
this.addPixels(codingLine[this.codingPos] +
code1, blackPixels);
if (codingLine[this.codingPos] < columns) {
this.addPixels(codingLine[this.codingPos] + code2,
blackPixels ^ 1);
}
while (refLine[refPos] <= codingLine[this.codingPos] && while (refLine[refPos] <= codingLine[this.codingPos] &&
refLine[refPos] < columns) { refLine[refPos] < columns) {
refPos += 2; refPos += 2;
} }
} break;
break; case twoDimVertR3:
case twoDimVertR1: this.addPixels(refLine[refPos] + 3, blackPixels);
this.addPixels(refLine[refPos] + 1, blackPixels); blackPixels ^= 1;
blackPixels ^= 1; if (codingLine[this.codingPos] < columns) {
if (codingLine[this.codingPos] < columns) {
++refPos;
while (refLine[refPos] <= codingLine[this.codingPos] &&
refLine[refPos] < columns)
refPos += 2;
}
break;
case twoDimVert0:
this.addPixels(refLine[refPos], blackPixels);
blackPixels ^= 1;
if (codingLine[this.codingPos] < columns) {
++refPos;
while (refLine[refPos] <= codingLine[this.codingPos] &&
refLine[refPos] < columns)
refPos += 2;
}
break;
case twoDimVertL3:
this.addPixelsNeg(refLine[refPos] - 3, blackPixels);
blackPixels ^= 1;
if (codingLine[this.codingPos] < columns) {
if (refPos > 0)
--refPos;
else
++refPos; ++refPos;
while (refLine[refPos] <= codingLine[this.codingPos] && while (refLine[refPos] <= codingLine[this.codingPos] &&
refLine[refPos] < columns) refLine[refPos] < columns)
refPos += 2; refPos += 2;
} }
break; break;
case twoDimVertL2: case twoDimVertR2:
this.addPixelsNeg(refLine[refPos] - 2, blackPixels); this.addPixels(refLine[refPos] + 2, blackPixels);
blackPixels ^= 1; blackPixels ^= 1;
if (codingLine[this.codingPos] < columns) { if (codingLine[this.codingPos] < columns) {
if (refPos > 0)
--refPos;
else
++refPos; ++refPos;
while (refLine[refPos] <= codingLine[this.codingPos] && while (refLine[refPos] <= codingLine[this.codingPos] &&
refLine[refPos] < columns) refLine[refPos] < columns) {
refPos += 2; refPos += 2;
} }
break; }
case twoDimVertL1: break;
this.addPixelsNeg(refLine[refPos] - 1, blackPixels); case twoDimVertR1:
blackPixels ^= 1; this.addPixels(refLine[refPos] + 1, blackPixels);
if (codingLine[this.codingPos] < columns) { blackPixels ^= 1;
if (refPos > 0) if (codingLine[this.codingPos] < columns) {
--refPos;
else
++refPos; ++refPos;
while (refLine[refPos] <= codingLine[this.codingPos] &&
refLine[refPos] < columns)
refPos += 2;
}
break;
case twoDimVert0:
this.addPixels(refLine[refPos], blackPixels);
blackPixels ^= 1;
if (codingLine[this.codingPos] < columns) {
++refPos;
while (refLine[refPos] <= codingLine[this.codingPos] &&
refLine[refPos] < columns)
refPos += 2;
}
break;
case twoDimVertL3:
this.addPixelsNeg(refLine[refPos] - 3, blackPixels);
blackPixels ^= 1;
if (codingLine[this.codingPos] < columns) {
if (refPos > 0)
--refPos;
else
++refPos;
while (refLine[refPos] <= codingLine[this.codingPos] &&
refLine[refPos] < columns)
refPos += 2;
}
break;
case twoDimVertL2:
this.addPixelsNeg(refLine[refPos] - 2, blackPixels);
blackPixels ^= 1;
if (codingLine[this.codingPos] < columns) {
if (refPos > 0)
--refPos;
else
++refPos;
while (refLine[refPos] <= codingLine[this.codingPos] &&
refLine[refPos] < columns)
refPos += 2;
}
break;
case twoDimVertL1:
this.addPixelsNeg(refLine[refPos] - 1, blackPixels);
blackPixels ^= 1;
if (codingLine[this.codingPos] < columns) {
if (refPos > 0)
--refPos;
else
++refPos;
while (refLine[refPos] <= codingLine[this.codingPos] && while (refLine[refPos] <= codingLine[this.codingPos] &&
refLine[refPos] < columns) refLine[refPos] < columns)
refPos += 2; refPos += 2;
} }
break; break;
case EOF: case EOF:
this.addPixels(columns, 0); this.addPixels(columns, 0);
this.eof = true; this.eof = true;
break; break;
default: default:
warn('bad 2d code'); warn('bad 2d code');
this.addPixels(columns, 0); this.addPixels(columns, 0);
this.err = true; this.err = true;
break;
} }
} }
} else { } else {
@ -2488,79 +2486,77 @@ var Lexer = (function() {
do { do {
ch = stream.getChar(); ch = stream.getChar();
switch (ch) { switch (ch) {
case undefined:
warn('Unterminated string');
done = true;
break;
case '(':
++numParen;
str += ch;
break;
case ')':
if (--numParen == 0) {
done = true;
} else {
str += ch;
}
break;
case '\\':
ch = stream.getChar();
switch (ch) {
case undefined: case undefined:
warn('Unterminated string'); warn('Unterminated string');
done = true; done = true;
break; break;
case 'n':
str += '\n';
break;
case 'r':
str += '\r';
break;
case 't':
str += '\t';
break;
case 'b':
str += '\b';
break;
case 'f':
str += '\f';
break;
case '\\':
case '(': case '(':
case ')': ++numParen;
str += ch; str += ch;
break; break;
case '0': case '1': case '2': case '3': case ')':
case '4': case '5': case '6': case '7': if (--numParen == 0) {
var x = ch - '0'; done = true;
ch = stream.lookChar(); } else {
if (ch >= '0' && ch <= '7') { str += ch;
stream.skip();
x = (x << 3) + (ch - '0');
ch = stream.lookChar();
if (ch >= '0' && ch <= '7') {
stream.skip();
x = (x << 3) + (ch - '0');
}
} }
break;
case '\\':
ch = stream.getChar();
switch (ch) {
case undefined:
warn('Unterminated string');
done = true;
break;
case 'n':
str += '\n';
break;
case 'r':
str += '\r';
break;
case 't':
str += '\t';
break;
case 'b':
str += '\b';
break;
case 'f':
str += '\f';
break;
case '\\':
case '(':
case ')':
str += ch;
break;
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
var x = ch - '0';
ch = stream.lookChar();
if (ch >= '0' && ch <= '7') {
stream.skip();
x = (x << 3) + (ch - '0');
ch = stream.lookChar();
if (ch >= '0' && ch <= '7') {
stream.skip();
x = (x << 3) + (ch - '0');
}
}
str += String.fromCharCode(x); str += String.fromCharCode(x);
break; break;
case '\r': case '\r':
ch = stream.lookChar(); ch = stream.lookChar();
if (ch == '\n') if (ch == '\n')
stream.skip(); stream.skip();
break; break;
case '\n': case '\n':
break;
default:
str += ch;
}
break; break;
default: default:
str += ch; str += ch;
break;
}
break;
default:
str += ch;
break;
} }
} while (!done); } while (!done);
return str; return str;
@ -2641,41 +2637,41 @@ var Lexer = (function() {
// start reading token // start reading token
switch (ch) { switch (ch) {
case '0': case '1': case '2': case '3': case '4': case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9': case '5': case '6': case '7': case '8': case '9':
case '+': case '-': case '.': case '+': case '-': case '.':
return this.getNumber(ch); return this.getNumber(ch);
case '(': case '(':
return this.getString(); return this.getString();
case '/': case '/':
return this.getName(ch); return this.getName(ch);
// array punctuation // array punctuation
case '[': case '[':
case ']': case ']':
return new Cmd(ch); return new Cmd(ch);
// hex string or dict punctuation // hex string or dict punctuation
case '<': case '<':
ch = stream.lookChar(); ch = stream.lookChar();
if (ch == '<') { if (ch == '<') {
// dict punctuation
stream.skip();
return new Cmd('<<');
}
return this.getHexString(ch);
// dict punctuation // dict punctuation
stream.skip(); case '>':
return new Cmd('<<'); ch = stream.lookChar();
} if (ch == '>') {
return this.getHexString(ch); stream.skip();
// dict punctuation return new Cmd('>>');
case '>': }
ch = stream.lookChar(); case '{':
if (ch == '>') { case '}':
stream.skip(); return new Cmd(ch);
return new Cmd('>>'); // fall through
} case ')':
case '{': error('Illegal character: ' + ch);
case '}': return Error;
return new Cmd(ch);
// fall through
case ')':
error('Illegal character: ' + ch);
return Error;
} }
// command // command
@ -3139,17 +3135,16 @@ var XRef = (function() {
entry.offset = offset; entry.offset = offset;
entry.gen = generation; entry.gen = generation;
switch (type) { switch (type) {
case 0: case 0:
entry.free = true; entry.free = true;
break; break;
case 1: case 1:
entry.uncompressed = true; entry.uncompressed = true;
break; break;
case 2: case 2:
break; break;
default: default:
error('Invalid XRef entry type: ' + type); error('Invalid XRef entry type: ' + type);
break;
} }
if (!this.entries[first + i]) if (!this.entries[first + i])
this.entries[first + i] = entry; this.entries[first + i] = entry;
@ -3483,7 +3478,6 @@ var Page = (function() {
break; break;
default: default:
TODO('other link types'); TODO('other link types');
break;
} }
} else if (annotation.has('Dest')) { } else if (annotation.has('Dest')) {
// simple destination link // simple destination link
@ -3713,7 +3707,9 @@ var PDFDoc = (function() {
if (find(stream, 'startxref', 1024, true)) { if (find(stream, 'startxref', 1024, true)) {
stream.skip(9); stream.skip(9);
var ch; var ch;
while (Lexer.isSpace(ch = stream.getChar())) {} do {
ch = stream.getChar();
} while (Lexer.isSpace(ch));
var str = ''; var str = '';
while ((ch - '0') <= 9) { while ((ch - '0') <= 9) {
str += ch; str += ch;
@ -4353,8 +4349,7 @@ var PartialEvaluator = (function() {
baseEncoding = Encodings.StandardEncoding.slice(); baseEncoding = Encodings.StandardEncoding.slice();
break; break;
default: default:
warn('Unknown type of font: ' + type); warn('Unknown type of font: ' + type);
break;
} }
} }
@ -4455,7 +4450,6 @@ var PartialEvaluator = (function() {
token = parseInt(token, 10); // a number token = parseInt(token, 10); // a number
tokens.push(token); tokens.push(token);
token = ''; token = '';
break;
} }
switch (byte) { switch (byte) {
case 0x5B: case 0x5B:
@ -4466,9 +4460,9 @@ var PartialEvaluator = (function() {
// collect array items // collect array items
var items = [], item; var items = [], item;
while (tokens.length && while (tokens.length &&
(item = tokens.pop()) != beginArrayToken) (item = tokens.pop()) != beginArrayToken)
items.unshift(item); items.unshift(item);
tokens.push(items); tokens.push(items);
break; break;
} }
} else if (byte == 0x3E) { } else if (byte == 0x3E) {
@ -5405,67 +5399,67 @@ var ColorSpace = (function() {
this.mode = mode; this.mode = mode;
switch (mode) { switch (mode) {
case 'DeviceGray': case 'DeviceGray':
case 'G': case 'G':
return new DeviceGrayCS(); return new DeviceGrayCS();
case 'DeviceRGB': case 'DeviceRGB':
case 'RGB': case 'RGB':
return new DeviceRgbCS(); return new DeviceRgbCS();
case 'DeviceCMYK': case 'DeviceCMYK':
case 'CMYK': case 'CMYK':
return new DeviceCmykCS(); return new DeviceCmykCS();
case 'Pattern': case 'Pattern':
return new PatternCS(null); return new PatternCS(null);
default: default:
error('unrecognized colorspace ' + mode); error('unrecognized colorspace ' + mode);
} }
} else if (IsArray(cs)) { } else if (IsArray(cs)) {
var mode = cs[0].name; var mode = cs[0].name;
this.mode = mode; this.mode = mode;
switch (mode) { switch (mode) {
case 'DeviceGray': case 'DeviceGray':
case 'G': case 'G':
return new DeviceGrayCS();
case 'DeviceRGB':
case 'RGB':
return new DeviceRgbCS();
case 'DeviceCMYK':
case 'CMYK':
return new DeviceCmykCS();
case 'CalGray':
return new DeviceGrayCS();
case 'CalRGB':
return new DeviceRgbCS();
case 'ICCBased':
var stream = xref.fetchIfRef(cs[1]);
var dict = stream.dict;
var numComps = dict.get('N');
if (numComps == 1)
return new DeviceGrayCS(); return new DeviceGrayCS();
if (numComps == 3) case 'DeviceRGB':
case 'RGB':
return new DeviceRgbCS(); return new DeviceRgbCS();
if (numComps == 4) case 'DeviceCMYK':
case 'CMYK':
return new DeviceCmykCS(); return new DeviceCmykCS();
break; case 'CalGray':
case 'Pattern': return new DeviceGrayCS();
var baseCS = cs[1]; case 'CalRGB':
if (baseCS) return new DeviceRgbCS();
baseCS = ColorSpace.parse(baseCS, xref, res); case 'ICCBased':
return new PatternCS(baseCS); var stream = xref.fetchIfRef(cs[1]);
case 'Indexed': var dict = stream.dict;
var base = ColorSpace.parse(cs[1], xref, res); var numComps = dict.get('N');
var hiVal = cs[2] + 1; if (numComps == 1)
var lookup = xref.fetchIfRef(cs[3]); return new DeviceGrayCS();
return new IndexedCS(base, hiVal, lookup); if (numComps == 3)
case 'Separation': return new DeviceRgbCS();
var alt = ColorSpace.parse(cs[2], xref, res); if (numComps == 4)
var tintFn = new PDFFunction(xref, xref.fetchIfRef(cs[3])); return new DeviceCmykCS();
return new SeparationCS(alt, tintFn); break;
case 'Lab': case 'Pattern':
case 'DeviceN': var baseCS = cs[1];
default: if (baseCS)
error('unimplemented color space object "' + mode + '"'); baseCS = ColorSpace.parse(baseCS, xref, res);
return new PatternCS(baseCS);
case 'Indexed':
var base = ColorSpace.parse(cs[1], xref, res);
var hiVal = cs[2] + 1;
var lookup = xref.fetchIfRef(cs[3]);
return new IndexedCS(base, hiVal, lookup);
case 'Separation':
var alt = ColorSpace.parse(cs[2], xref, res);
var tintFn = new PDFFunction(xref, xref.fetchIfRef(cs[3]));
return new SeparationCS(alt, tintFn);
case 'Lab':
case 'DeviceN':
default:
error('unimplemented color space object "' + mode + '"');
} }
} else { } else {
error('unrecognized color space object: "' + cs + '"'); error('unrecognized color space object: "' + cs + '"');
@ -5748,26 +5742,26 @@ var Pattern = (function() {
var typeNum = dict.get('PatternType'); var typeNum = dict.get('PatternType');
switch (typeNum) { switch (typeNum) {
case 1: case 1:
var base = cs.base; var base = cs.base;
var color; var color;
if (base) { if (base) {
var baseComps = base.numComps; var baseComps = base.numComps;
color = []; color = [];
for (var i = 0; i < baseComps; ++i) for (var i = 0; i < baseComps; ++i)
color.push(args[i]); color.push(args[i]);
color = base.getRgb(color); color = base.getRgb(color);
} }
var code = patternName.code; var code = patternName.code;
return new TilingPattern(pattern, code, dict, color, xref, ctx); return new TilingPattern(pattern, code, dict, color, xref, ctx);
case 2: case 2:
var shading = xref.fetchIfRef(dict.get('Shading')); var shading = xref.fetchIfRef(dict.get('Shading'));
var matrix = dict.get('Matrix'); var matrix = dict.get('Matrix');
return Pattern.parseShading(shading, matrix, xref, res, ctx); return Pattern.parseShading(shading, matrix, xref, res, ctx);
default: default:
error('Unknown type of pattern: ' + typeNum); error('Unknown type of pattern: ' + typeNum);
} }
return null; return null;
}; };
@ -5779,12 +5773,12 @@ var Pattern = (function() {
var type = dict.get('ShadingType'); var type = dict.get('ShadingType');
switch (type) { switch (type) {
case 2: case 2:
case 3: case 3:
// both radial and axial shadings are handled by RadialAxial shading // both radial and axial shadings are handled by RadialAxial shading
return new RadialAxialShading(dict, matrix, xref, res, ctx); return new RadialAxialShading(dict, matrix, xref, res, ctx);
default: default:
return new DummyShading(); return new DummyShading();
} }
}; };
return constructor; return constructor;
@ -5965,17 +5959,17 @@ var TilingPattern = (function() {
var paintType = dict.get('PaintType'); var paintType = dict.get('PaintType');
switch (paintType) { switch (paintType) {
case PAINT_TYPE_COLORED: case PAINT_TYPE_COLORED:
tmpCtx.fillStyle = ctx.fillStyle; tmpCtx.fillStyle = ctx.fillStyle;
tmpCtx.strokeStyle = ctx.strokeStyle; tmpCtx.strokeStyle = ctx.strokeStyle;
break; break;
case PAINT_TYPE_UNCOLORED: case PAINT_TYPE_UNCOLORED:
color = Util.makeCssRgb.apply(this, color); color = Util.makeCssRgb.apply(this, color);
tmpCtx.fillStyle = color; tmpCtx.fillStyle = color;
tmpCtx.strokeStyle = color; tmpCtx.strokeStyle = color;
break; break;
default: default:
error('Unsupported paint type: ' + paintType); error('Unsupported paint type: ' + paintType);
} }
var scale = [width / xstep, height / ystep]; var scale = [width / xstep, height / ystep];