Skip to content

Instantly share code, notes, and snippets.

@kdzwinel kdzwinel/jsk.c
Created Jan 19, 2017

Embed
What would you like to do?
JSK -JPEG Scan Killer
/*
* jsk.c
*
* Copyright (C) 2013, Frederic Kayser.
*
*/
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdint.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifdef WIN32
# include <io.h>
#endif
#define errorxt(msg) (fprintf(stderr, "%s\n", msg), exit(1))
#define jsk_version "0.1 (24 Sept. 2013)"
/*
* JPEG markers consist of one or more 0xFF bytes, followed by a marker
* code (which is not 0xFF).
*/
#define M_PAD 0x00 /* Padding byte used when 0xFF is found in compressed data */
#define M_RST0 0xD0 /* Restart Markers 0-7, related to DRI */
#define M_RST1 0xD1
#define M_RST2 0xD2
#define M_RST3 0xD3
#define M_RST4 0xD4
#define M_RST5 0xD5
#define M_RST6 0xD6
#define M_RST7 0xD7
#define M_SOI 0xD8 /* Start of Image */
#define M_EOI 0xD9 /* End of Image */
#define M_SOS 0xDA /* Start of Scan (size is not known) */
#define M_DRI 0xDD /* Define Restart Interval */
#define local static /* for local function definitions */
/* These are global variables, this is baaaad !!! */
uint8_t *jpg_buff;
size_t size, cur_pos;
/* Read a 16 bits value from the buffer */
static uint16_t read_two (void)
{
if ((cur_pos+1) < size) {
uint16_t beammeup;
beammeup = jpg_buff[cur_pos++] << 8;
beammeup += jpg_buff[cur_pos++];
return beammeup;
}
else
errorxt("Premature EOF in JPEG file");
}
/* Read an 8 bits value from the buffer */
static uint8_t read_one (void)
{
if (cur_pos < size)
return (uint8_t)(jpg_buff[cur_pos++]);
else
errorxt("Premature EOF in JPEG file");
}
/* Find the next JPEG marker */
static uint8_t next_marker (void)
{
uint8_t c;
/* Find 0xFF byte (marker head). */
c = read_one();
while (c != 0xFF) {
c = read_one();
}
/* Get marker code, swallowing any duplicate FF bytes.
* (extra FFs are legal as pad bytes)
*/
do {
c = read_one();
} while (c == 0xFF);
return c;
}
/* Skip over a marker of known size */
static void skip_marker (void)
{
uint16_t length;
/* Read the marker length */
length = read_two();
/* Length includes itself, must be at least 2 */
if (length < 2)
errorxt("Erroneous JPEG marker length");
length -= 2;
/* Skip length bytes */
if (cur_pos+length < size)
cur_pos += length;
else
errorxt("Erroneous JPEG marker length");
}
static void skip_SOS (void)
{
uint8_t c;
/* Since the scan size is not known in advance it is parsed until we find a new marker */
/* Find 0xFF bytes inside current scan, these could be internal markers */
for (;;) {
c = read_one();
while (c != 0xFF) {
c = read_one();
}
do {
c = read_one();
} while (c == 0xFF);
switch (c) {
case M_PAD: break; /* 0xFF was part of the compressed stream and was 0x00 padded*/
case M_RST0: c = 0 ; break; /* Swallow eventual Restart Markers */
case M_RST1: c = 0 ; break;
case M_RST2: c = 0 ; break;
case M_RST3: c = 0 ; break;
case M_RST4: c = 0 ; break;
case M_RST5: c = 0 ; break;
case M_RST6: c = 0 ; break;
case M_RST7: c = 0 ; break;
default: break;
}
if (c!=0) { /* The end of the current scan has been reached */
cur_pos -= 2; /* Rollback for next_marker */
break; /* Leave the loop */
}
}
}
void usage(FILE *fpMsg)
{
fprintf(fpMsg, "JSK, version %s by Frederic Kayser.\n", jsk_version);
fprintf(fpMsg,
"Splits a JPEG file in multiple scan_xxx.jpg files.\n"
"Usage: jsk [-h] file.jpg\n"
"Options:\n"
" -h display this help message\n");
}
int main(int argc, char *argv[])
{
uint32_t i = 1;
struct stat sbuf;
char *fname1;
uint8_t marker;
size_t data_io_size;
char out_name[] = "scan_000.jpg";
uint8_t ffd9[2] = {0xFF, 0xD9};
FILE *fp1;
while (argc > 1 && argv[1][0] == '-') {
switch (argv[1][i]) {
case '\0':
--argc;
++argv;
i = 1;
break;
case 'h':
usage(stdout);
exit (0);
default:
fprintf(stderr, "Unknown option %c\n\n", argv[1][i]);
usage(stderr);
exit (1);
}
}
if (argc != 2) {
usage(stderr);
exit (1);
}
else { /* Open the input file and load it in memory */
fname1 = argv[1];
if (lstat(fname1, &sbuf)) {
fprintf(stderr, "%s: does not exist!\n", fname1);
exit (1);
}
if (S_ISDIR(sbuf.st_mode)) {
fprintf(stderr, "%s: is a folder - ignored\n", fname1);
exit (1);
}
size = sbuf.st_size;
if ((fp1 = fopen(fname1, "rb")) == NULL) {
fprintf(stderr, "%s: could not open file!\n", fname1);
exit (1);
}
jpg_buff = malloc(size);
if (jpg_buff == NULL) {
fprintf(stderr, "Malloc failed miserably!\n");
exit (1);
}
data_io_size = fread(jpg_buff, 1, size, fp1);
if (data_io_size != (size_t)(size)) {
fprintf(stderr, "%s: EOF while reading input!\n", fname1);
exit (1);
}
fclose(fp1);
/* Check that the file is effectively a JPEG */
if (read_two() != 0xFFD8)
errorxt("Input is not a JPEG file");
/* Scan markers until EOI and treat SOS */
do {
marker = next_marker();
if (marker == M_SOS) {
skip_SOS(); /* Jump to the end of the scan */
/* Increment the scan counter in the output file name */
if (out_name[7]!='9')
++out_name[7];
else {
out_name[7]='0';
if (out_name[6]!='9')
++out_name[6];
else {
out_name[6]='0';
++out_name[5]; /* 999 scans ought to be enough for anybody */
}
}
/* Write everything from the begining of the file to the end of the current scan */
fp1 = fopen(out_name, "wb");
if (fp1 == NULL) {
fprintf(stderr, "Could not open output file: %s.\n", out_name);
exit (1);
}
data_io_size = fwrite(jpg_buff, 1, cur_pos, fp1);
if (data_io_size != cur_pos) {
errorxt("Could not write entire output file!");
}
/* Add an End of Image marker at the end of the file */
data_io_size = fwrite(ffd9, 1, 2, fp1);
if (data_io_size != 2) {
errorxt("Could not add End Of Image to the output file!");
}
fclose(fp1);
}
else if (marker != M_EOI) { /* Anything else is skipped */
skip_marker();
}
} while (marker != M_EOI); /* End of Image: we are done */
}
return 0;
}
@kdzwinel

This comment has been minimized.

Copy link
Owner Author

kdzwinel commented Jan 19, 2017

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.