Ideas for image compression feature [add more quality options]

webratte · March 15, 2019, 5:18am

Thank you for the Image compression option (experimental feature).

I have a few ideas for refine this feature.
Add more compression options (values stolen from a other messenger):

High quality (2 MP)
medium quality (1 MP)
low quality (0,4 MP)
original (unchanged)
ask everytime before sending

If this point is choosed, open a pop up window with the options to choose the size of the picture.
If you like you also can show in this window a checkmark (unchecked by default) remember this choice.

Background of this wish:
Sometimes I need a high quality pic (maybe in HD). And sometimes I only send only a funny pic with low priority.
And I don’t want go everytime to global settings.

r10s · March 15, 2019, 6:06am

you can send images using Attach / Files if you want to bypass the compression.

so, there is no need to go to the settings if you want to send a file uncompressed (which is is a bad idea in most situations, as it wastes a lot of data)

in general, adding options is not what we’re usually doing in Delta Chat. Delta Chat is meant for the non-advanced user, that does not even think about that. one would select “Good Quality” - because it sounds good - not thinking that it affects the receiver more than oneself (messages are more often downloaded than uploaded).
but of course, the given default should be as good as possible, and there is room for improvement, always.

EDIT: meanwhile, we have a low-bandwidth option at Chats / Outgoing Media Quality, used eg. in the Rain Forests, where messages are relayed with radio waves. Or in Cuba, or wherever you have a really bad network or super-expensive costs. we’re talking about messages needing minutes to go out here. the setting affects images as well as video and voice messages.

but for now, we do not want ot have more options there, for reasons pointed out above.

webratte · March 15, 2019, 7:00am

Hi,
most messenger (that I know) work the way I described. So it can’t be the worst way.

The “ask everytime before sending” would be a unique feature. That’s what I miss in every messenger I know.

And it gives the user more control of his/here pics.

You say it effect both sides. This is correct.
Other messengers handle it this way:

Optionally download only attachments smaller then x MB or in WiFi.
All other download by long press the thumbnail.
Also as a user preference.

OK, sending uncompressed Pics as File is a workaround I can live with it.
Not nice but possible

Still I think it would not hurt if it’s not to hard to implement.
It’s a user preference.

adbenitez · March 15, 2019, 1:40pm

+1 for:

Highly compressed audio and media in general, is highly needed for people on slow/paid networks, specially for the situation of Cubans.

anon93826752 · March 15, 2019, 4:42pm

Then it’ll implement https://github.com/rcanut/nhwcodec on deltachat-core

bokf · January 17, 2020, 9:45pm

I also like the possibility to choose from more options to compress pictures. The advantage of DeltaChat in comparison to the other messenger is, that you have the pictures inmediately as email on your computer and you do not have to look it on the small Mickey Mouse screen of the phone. I like it to look at the pictures fullscreen on the computer and the screens are growing and growing … so I would like to have the possibility to have the pictures in higher resolution.

Simon · January 18, 2020, 2:51am

When having that feature we need to show the resulting size before sending.
Otherwise the users get surprised by an full email account or empty mobile data plan.
Also I would postpone this until we have (Addition of automatic media download feature, that feature was also mentioned in this thread by webratte).

yaah2222 · February 27, 2026, 2:10pm

That’s a great idea!
Please add
Outgoing Media Quality - without compression (Original)

SWEETGOOD · March 11, 2026, 9:11pm

This topic has been discussed widely and unfortunately the default compression algorithm is not really good.

Regarding your question: You can already achieve this by sending the image as a file. Then the original quality without any compression will be preserved (but also the original file size).

I also think there should at least be another “good” compression option in the list as well. I quote what I wrote in another thread about that:

Image compression

Another frustrating feature is the image compression. As I described here the default image compression “balanced” is showing visible compression artifacts (from a viewers perspective) and there’s no option to choose a less destructive compression level (apart from sending the original probably oversized file producing other problems).

I want to add that the argument of sending images as file in original quality (which was already repeated many times) as a workaround is not sufficient for most use cases.

The FAQ states about the default compression algorithm “This is ideal for everyday communication.” – and from my perspective this is not the case. The quality is worse than the default with any other messenger. I think they should be the reference when talking about everyday communication as billions of people are using them day by day. So an option which does compression but in a less destructive way could be a simple fix.

Sending pictures uncompressed comes also with another very bad downside:
Storage limits on all sides

I don’t want to have 500MB wasted on ALL of my devices I use Delta Chat on just because a family member sent me all pictures of the last vacation as files because Delta Chats compression algorithm is too bad to send them as images. A normal compressed JPG has around 250 - 500KB, an uncompressed one 5-7 MB. That’s a huge difference.

EDIT:
I think I found the “issue” why the devs are not just implementing it. They would have to adapt the CORE library too. The quality settings in the Delta Chat Desktop client were changed 2 years ago and the compression does NOT take place there (I thought that before).

You can get a picture of how the compression is implemented by taking a look at these files:

github.com/chatmail/core

src/blob.rs

3c5af7a55


      
              let viewtype = &mut Viewtype::Image;
              let is_avatar = true;
              self.check_or_recode_to_size(
                  context, None, // The name of an avatar doesn't matter
                  viewtype, max_wh, max_bytes, is_avatar,
              )?;
          
              Ok(())
          }
          
          /// Checks or recodes an image pointed by the [BlobObject] so that it fits into limits on the
          /// image width, height and file size specified by the config.
          ///
          /// Recoding is only done for [`Viewtype::Image`]. For [`Viewtype::File`], if it's a correct
          /// image, `*viewtype` is set to [`Viewtype::Image`].
          ///
          /// On some platforms images are passed to Core as [`Viewtype::Sticker`]. We recheck if the
          /// image is a true sticker assuming that it must have at least one fully transparent corner,
          /// otherwise `*viewtype` is set to [`Viewtype::Image`].
          pub async fn check_or_recode_image(
              &mut self,

github.com/chatmail/core

deltachat-rpc-client/src/deltachat_rpc_client/const.py

3c5af7a55


      
          
          
          # "Lp" means "login parameters"
          class LpAuthFlag(IntEnum):
              """Authorization flags."""
          
              OAUTH2 = 0x2
              NORMAL = 0x4
          
          
          class MediaQuality(IntEnum):
              """Media quality setting."""
          
              BALANCED = 0
              WORSE = 1
          
          
          class ProviderStatus(IntEnum):
              """Provider status according to manual testing."""
          
              OK = 1

github.com/chatmail/core

deltachat-ffi/deltachat.h

3c5af7a55


      
          * ~~~
          * dc_msg_t* msg = dc_msg_new(context, DC_MSG_IMAGE);
          *
          * dc_msg_set_file_and_deduplicate(msg, "/file/to/send.jpg", NULL, NULL);
          * dc_send_msg(context, chat_id, msg);
          *
          * dc_msg_unref(msg);
          * ~~~
          *
          * If you send images with the #DC_MSG_IMAGE type,
          * they will be recoded to a reasonable size before sending, if possible
          * (cmp the dc_set_config()-option `media_quality`).
          * If that fails, is not possible, or the image is already small enough, the image is sent as original.
          * If you want images to be always sent as the original file, use the #DC_MSG_FILE type.
          *
          * Videos and other file types are currently not recoded by the library.
          *
          * @memberof dc_context_t
          * @param context The context object as returned from dc_context_new().
          * @param chat_id The chat ID to send the message to.
          * @param msg The message object to send to the chat defined by the chat ID.

They not only set a compression factor (jpeg_quality) but also a target file size (max_bytes) (which should not be exceeded) and a target resolution (target_wh), see

github.com/chatmail/core

src/constants.rs

3c5af7a55


      
          pub const DC_LP_AUTH_OAUTH2: i32 = 0x2;
          
          /// Force NORMAL authorization, this is the default.
          /// If this flag is set, automatic configuration is skipped.
          pub const DC_LP_AUTH_NORMAL: i32 = 0x4;
          
          /// if none of these flags are set, the default is chosen
          pub const DC_LP_AUTH_FLAGS: i32 = DC_LP_AUTH_OAUTH2 | DC_LP_AUTH_NORMAL;
          
          // max. weight of images to send w/o recoding
          pub const BALANCED_IMAGE_BYTES: usize = 500_000;
          pub const WORSE_IMAGE_BYTES: usize = 130_000;
          
          // max. width/height and bytes of an avatar
          pub(crate) const BALANCED_AVATAR_SIZE: u32 = 512;
          pub(crate) const BALANCED_AVATAR_BYTES: usize = 60_000;
          pub(crate) const WORSE_AVATAR_SIZE: u32 = 128;
          pub(crate) const WORSE_AVATAR_BYTES: usize = 20_000; // this also fits to Outlook servers don't allowing headers larger than 32k.
          
          // max. width/height of images scaled down because of being too huge
          pub const BALANCED_IMAGE_SIZE: u32 = 1280;

github.com/chatmail/core

src/constants.rs

3c5af7a55


      
          pub const BALANCED_IMAGE_BYTES: usize = 500_000;
          pub const WORSE_IMAGE_BYTES: usize = 130_000;
          
          // max. width/height and bytes of an avatar
          pub(crate) const BALANCED_AVATAR_SIZE: u32 = 512;
          pub(crate) const BALANCED_AVATAR_BYTES: usize = 60_000;
          pub(crate) const WORSE_AVATAR_SIZE: u32 = 128;
          pub(crate) const WORSE_AVATAR_BYTES: usize = 20_000; // this also fits to Outlook servers don't allowing headers larger than 32k.
          
          // max. width/height of images scaled down because of being too huge
          pub const BALANCED_IMAGE_SIZE: u32 = 1280;
          pub const WORSE_IMAGE_SIZE: u32 = 640;
          
          /// Limit for received images size. Bigger images become `Viewtype::File` to avoid excessive memory
          /// usage by UIs.
          pub const MAX_RCVD_IMAGE_PIXELS: u32 = 50_000_000;
          
          // Key for the folder configuration version (see below).
          pub(crate) const DC_FOLDERS_CONFIGURED_KEY: &str = "folders_configured";
          // this value can be increased if the folder configuration is changed and must be redone on next program start
          pub(crate) const DC_FOLDERS_CONFIGURED_VERSION: i32 = 5;

Also the image quality is hardcoded to 75 (85 would be my selection for good results):

github.com/chatmail/core

src/blob.rs

3c5af7a55


      
          // max_wh is the maximum image width and height, i.e. the resolution-limit.
          // target_wh target-resolution for resizing the image.
          let exceeds_wh = img.width() > max_wh || img.height() > max_wh;
          let mut target_wh = if exceeds_wh {
              max_wh
          } else {
              max(img.width(), img.height())
          };
          let exceeds_max_bytes = nr_bytes > max_bytes as u64;
          
          let jpeg_quality = 75;
          let ofmt = match fmt {
              ImageFormat::Png if !exceeds_max_bytes => ImageOutputFormat::Png,
              ImageFormat::Jpeg => {
                  add_white_bg = false;
                  ImageOutputFormat::Jpeg {
                      quality: jpeg_quality,
                  }
              }
              _ => ImageOutputFormat::Jpeg {
                  quality: jpeg_quality,

An argument why they might have choosen this can probably be found in this comment:

github.com/chatmail/core

src/blob.rs

3c5af7a55


      
          if do_scale {
              loop {
                  if mem::take(&mut add_white_bg) {
                      self::add_white_bg(&mut img);
                  }
          
                  // resize() results in often slightly better quality,
                  // however, comes at high price of being 4+ times slower than thumbnail().
                  // for a typical camera image that is sent, this may be a change from "instant" (500ms) to "long time waiting" (3s).
                  // as we do not have recoding in background while chat has already a preview,
                  // we vote for speed.
                  // exception is the avatar image: this is far more often sent than recoded,
                  // usually has less pixels by cropping, UI that needs to wait anyways,
                  // and also benefits from slightly better (5%) encoding of Triangle-filtered images.
                  let new_img = if is_avatar {
                      img.resize(target_wh, target_wh, image::imageops::FilterType::Triangle)
                  } else {
                      img.thumbnail(target_wh, target_wh)
                  };
          
                  if encoded_img_exceeds_bytes(

So for now I don’t expect a “quick fix” by the devs because they would have to adapt the core library for that.

r10s · March 12, 2026, 8:53am

for the scepticism of adding options, everything is said above.

So for now I don’t expect a “quick fix” by the devs because they would have to adapt the core library for that.

well, in fact, there are quite some image improvements done the last weeks or on the way, see Pull requests · chatmail/core · GitHub - all improving within the given constraints, which are similar to eg. telegram, btw.

it seems also be possible to improve rendering of big screenshots as Image optimization - #6 by SWEETGOOD, that should be regarded more as a bug, as the 500k are not used.

EDIT: i created an issue for that at screenshots are sometimes sent in poor quality · Issue #7977 · chatmail/core · GitHub - ftr, it is interesting to browse a bit through the linked issues from the past, there are also lots of screenshots, examples, reasoning