Can someone explain this phenomenon? Are jpgs just that inefficient?

Can someone explain this phenomenon? Are jpgs just that inefficient?

Will this image ever be posted where the actual size is 410kb?

the game isn't a slide show
no images are put together like in that screenshot

jpgs are for photos, pngs are for flat color art.

also that's a troll image

...

...

...

maybe dont scale the image

Try to decrease resolution to 640x480?

>mario bros is 31kb

haha more like 31MB

>Already down to 3KB
>Image still 1115x833

Seems like the question has been answered.

please leave this board and the whole internet in fact right this moment

idiot

Artist who knows how to paint a picture is probably less information stored than a transcript of every blob of paint on the canvas. Don't listen to me I'm in a bait thread anyway

the game was optimized to one architecture to run under one platform to run under one set of circumstances using tricks to draw the graphics

imagine if images only worked on firefox and you only had a limited set of colors, you could easily make a less than 1kb image of essentially references to firefoxes color pallete with encoding tricks (the next 4 blocks will be blue so 4b to represent 4 bits instead of bbbb, etc)

troll image aside, I've read some interesting articles about this topic. Namely how the huge improvements in hardware has left software way behind. There's an argument to be made about how the abundance of memory and cpu power has led to progressively shittier and lazier code over time.

>save as bmp
>1,470 KB
>incredible programming skills

You can create a program that fills a bitmap with pseudorandom colors and it will be no larger than a few hundred bytes when compiled, yet the images it produces would be far larger than that.

You've just discovered vector graphics.

you can write a one function program in c that just dumps 0x0 into a file over and over again. The program will be a few hundred bytes, the output could be tens of gigs. Normies dont understand this sort of stuff though, so it seems impressive to them.

Wuh? NES was pixel-based. It just only used 2 bits per pixels and could only remember like 128*64 pixels at a time.

Not that there weren't some interesting vector graphics consoles in the early days.

N-NANI?!

haha

8x8 4 color tiles with palette swapping, didnt take much room up

Heres what the memory looks like

Nigger.

Vector graphics is about describing how to draw something instead of describing it pixel by pixel. The super mario executable is a way of describing how to draw super mario.

No, because retards on twitter dont know how to download images.

But NES DOES draw it pixel-by-pixel. It's not vector based, it's sprite based.

If you're trying to use the word "vector" to mean anything that is even vaguely procedural, you're using the word wrong. Vectors are lines.

What is this wizardry?

31megs ahahahah. You made me laugh hard m8

yeah but the system that runs it has a few KB extra to decode and process everything

>3430
Are you even trying?

the contents of that scene from the NES's point of view is just;
- a map of tiles, tiny
- a handful of unique tile contents, pretty small, but probably the largest portion of the data in the scene
- 2 sprites, bitmaps like tiles, only they're used differently

NES games rarely, if at all, contain full screen images, and even then they're mostly edited down to a minimum number of unique tiles to save space

Every image is drawn pixel by pixel you retard. The point here is that the image is not _stored_ pixel by pixel, rather by describing how to draw it. Just like in vector graphics formats.

(And yes, I know that JPEG doesn't store pixels either, rather Huffman-coded DCT coefficients, but you get the idea...)

Image is O(n2) in memory
NES games render in O(n2) time, with the use of small pieces of data that highly repeats itself.

You can also think that rendering is not an invertible function, and the set of operations done pre-rendering are lost when the final image is composed (f(S) is not invertible)

But.... it IS stored pixel by pixel. See .

>Can't get to 1KB
Try again, kid.

It's only a very small tilemap that's stored pixel by pixel.

Yes, a very small pixel map. Often called a sprite. Never ever in a million years called a vector. Sorry, bro, but you gotta pick your battles better.

Please go and watch 8bitsguy.

how much does the game take in RAM tho ?

>software is behind
>what is silicon

There is no software limitation, we can write a simulation of the universe each 10^80 atom individually right now, we just don't have the hardware to process or store it.

8 KB probably, at least that's true for the corresponding GB game.

Outta way nerds

shit tier

I'm sure if you brought the greatest demo minds together, they'd find a way to put a modern game in under a few megabyte (the entire human genome is 750 MB or so)

Why isn't there a format compression that compresses tiles? clearly all the floor tiles are just the same, the patron is repeating yet this is not being considered to improve the compression.

a jpg could never beat a well pallette-optimized png

You are fucking retarded, just FYI.

SVG is a vector graphics format. This is an SVG snippet that's referencing a PNG to use it as a fill pattern:





How is this different from super mario's usage of sprites?
And yes, I know that super mario is an executable, and not a vector graphics format, but these are analogous: they both describe what to draw and where via instructions. SVG's instructions are defined in the SVG XML schema, while super mario uses the CPU's instructions directly.

...

You scaled it down with paint or what?

Sure, but that's not necessarily the same point. I'm talking more about how games and other programs can come out now with horrifying memory management etc. simply because they can.

Raster graphics is based on pixels.
Vector graphics is based on geometrical shapes.
It's not that hard to understand........... kid.

"Clearly" to you, the human, not to the computer. The problem is of compressing algorithms is literally to find those repeating patterns, but at the same time not taking long enough to find the best one. It's a P=NP problem, actually.

...

I think what he means is that software and game devs had to come up with efficient or clever solutions because of limitation of hardware, such as memory. Now that hardware is so advanced, there's less of an incentive to come up with those types of solutions.

I can record a wav file of a music track from the game and encode it as an mp3 to bring it down to a couple MB. Meanwhile, the entire game's OST can fit into an NSF file which could be as small as 5KB for some games. Even games with a lot of music usually won't be much larger than 100KB.

The trick is you aren't recording sound in an NSF file, you're just storing the commands that the game would usually send to the sound chip, and the player emulates the sound chip to play the music.

...

...

nice loss of information faggots

...

anything from the original information isn't actually lost, it's only compressed into an tiny tiny space, all the stuff is still there

by that logic every image is a vector image, because computers really store information and not images

They just Derived the original information, what you can't even antiderivate it to the orignal state? sad!

...

Wrong, you can't recover (or decompress) the original image from the tiny one.

This Piece Of Shit Said It Was Corrupted Fuck You and Fuck 4shit

The point is they could do the double of the calculations if it was coded decently taking full advantage of the hardware
Not in the era of javascript

You can if you apply the exact reverse process that made the image lossy

autism

Well it's supposed to be KB, not Kb so....

Prove you can't

...

Is that the exact same process in reverse? And I don't mean mspaint scale function

The code waits 1000 days then returns the current date. So dumb.

You realize sleep is in milleseconds?

too bad i said kb, which's monotony indicates KB but lazily typed in lower case kb

Yes it's the same process you idiot. Fun fact for you: scaling is not lossless.

Not on any platform that matters.

Nice trips btw

assuming the function used to convert A(original) to B(lossy) has an inverse function then f'(B)=A, you did upscale(B)=A not f'

are you fucking retarded
kys

Underrated post

B is the new original, dumbo. It is literally impossible to gain back original data after scaling down an image.

by that logic, everyone loves Hitler. I bet you voted for Donald Trump too.

>they both describe what to draw and where via instructions
The definition of vector graphics is not that broad. It only refers to geometric shapes defined through coordinates and formulas, not finite-resolution bitmaps.

Also protip: just because a format is called Scalable Vector Graphics, that doesn't mean that every feature it supports is scalable and vector. Raster fill is a raster feature.

There kind of is. It's called google RAISR and works by training a neutral network with a large set of images, recognizing smaller parts of an image and upscaling them to the trained set.
It's primary use for now is upscaling images on g+

You must be the dumbest nigger ape alive.

file size means shit when actual memory usage in RAM is way above that. Game resolution is 256 × 224 with most of its elements being tiles of something way smaller, like the blocks on the ground, the clouds and the bushes being the same object with different color. Game also was coded in assembly almost procedural so it could fit inside cheap cartridges to be sold.

I remember that there were a game with 73kb that had full 3D cenario with lighting and shadow effects, it loaded close to 400mb in the RAM. But I can't find it.

Lossy methods aren't invertible retard fag

>assuming the function used to convert A
Assuming you are a faggot you sucked you're father's dick.

The definition of lossy conversion f is that it has no inverse.

...

...

software just grows to fit the hardware it has available. or rather, software engineers aren't computer scientists and are whipped to create a good user experience. They will create software to match the hardware.

Games like SMB use tiling to draw the game, you can see the repeated tiles in that image, like the blocks, characters and repeating floor pattern.

How far can science go?

there are no blurs, hence a smaller binary tree needed to represent the image because less changes/variations are required. everything has a very distinct break

Smallest I can go

>Are jpgs just that inefficient?
No, you're just that retarded.

Is that the best you can do?
Beat this. Protip: You fuking cannot.

You literally can't because Sup Forums says the image is corrupt (it lacks information that defines it as a GIF)

File size: 26 bytes
Have a GNU head instead

Is it even possible for an image to be under 1Kilo?