slidge-whatsapp 0.2.0b0__tar.gz → 0.2.1__tar.gz

{slidge_whatsapp-0.2.0b0 → slidge_whatsapp-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: slidge-whatsapp
-Version: 0.2.0b0
+Version: 0.2.1
 Summary: A Whatsapp/XMPP gateway.
 Author: deuill
 Author-email: alex@deuill.org
@@ -8,6 +8,7 @@ Requires-Python: >=3.11,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: linkpreview (>=0.6.5,<0.7.0)
 Requires-Dist: pybindgen (>=0.22.1,<0.23.0)
 Requires-Dist: slidge (>=0.2.0beta0,<0.3.0)

{slidge_whatsapp-0.2.0b0 → slidge_whatsapp-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "slidge-whatsapp"
-version = "0.2.0beta"
+version = "0.2.1"
 description = "A Whatsapp/XMPP gateway."
 authors = ["deuill <alex@deuill.org>", "Nicoco <nicoco@nicoco.fr>"]
 readme = "README.md"

{slidge_whatsapp-0.2.0b0 → slidge_whatsapp-0.2.1}/slidge_whatsapp/__init__.py

@@ -13,5 +13,5 @@ def main():
     entrypoint("slidge_whatsapp")
 
 
-__version__ = "0.2.0beta"
+__version__ = "0.2.1"
 __all__ = "Gateway", "session", "command", "contact", "config", "group", "main"

{slidge_whatsapp-0.2.0b0 → slidge_whatsapp-0.2.1}/slidge_whatsapp/config.py

@@ -26,12 +26,6 @@ ALWAYS_SYNC_ROSTER__DOC = (
     "Whether or not to perform a full sync of the WhatsApp roster on startup."
 )
 
-SKIP_VERIFY_TLS = False
-SKIP_VERIFY_TLS__DOC = (
-    "Whether or not HTTPS connections made by this plugin should verify TLS"
-    " certificates."
-)
-
 ENABLE_LINK_PREVIEWS = True
 ENABLE_LINK_PREVIEWS__DOC = (
     "Whether or not previews for links (URLs) should be generated on outgoing messages"

{slidge_whatsapp-0.2.0b0 → slidge_whatsapp-0.2.1}/slidge_whatsapp/contact.py

@@ -47,16 +47,18 @@ class Roster(LegacyRoster[str, Contact]):
         """
         Adds a WhatsApp contact to local roster, filling all required and optional information.
         """
+        # Don't attempt to add ourselves to the roster.
         if data.JID == self.user_legacy_id:
-            # with the current implementation, we don't allow that
             return None
         contact = await self.by_legacy_id(data.JID)
         contact.name = data.Name
         contact.is_friend = True
         try:
             avatar = self.session.whatsapp.GetAvatar(data.JID, contact.avatar or "")
-            if avatar.URL:
+            if avatar.URL and contact.avatar != avatar.ID:
                 await contact.set_avatar(avatar.URL, avatar.ID)
+            elif avatar.URL == "":
+                await contact.set_avatar(None)
         except RuntimeError as err:
             self.session.log.error(
                 "Failed getting avatar for contact %s: %s", data.JID, err

{slidge_whatsapp-0.2.0b0 → slidge_whatsapp-0.2.1}/slidge_whatsapp/event.go

@@ -2,13 +2,18 @@ package whatsapp
 
 import (
 	// Standard library.
+	"bytes"
 	"context"
 	"fmt"
+	"image/gif"
 	"mime"
-	"os"
 	"strings"
 
+	// Internal packages.
+	"git.sr.ht/~nicoco/slidge-whatsapp/slidge_whatsapp/media"
+
 	// Third-party libraries.
+	"github.com/h2non/filetype"
 	"go.mau.fi/whatsmeow"
 	"go.mau.fi/whatsmeow/proto/waE2E"
 	"go.mau.fi/whatsmeow/proto/waWeb"
@@ -25,7 +30,7 @@ const (
 	EventUnknown EventKind = iota
 	EventQRCode
 	EventPair
-	EventConnected
+	EventConnect
 	EventLoggedOut
 	EventContact
 	EventPresence
@@ -42,7 +47,7 @@ const (
 type EventPayload struct {
 	QRCode       string
 	PairDeviceID string
-	ConnectedJID string
+	Connect      Connect
 	Contact      Contact
 	Presence     Presence
 	Message      Message
@@ -52,6 +57,17 @@ type EventPayload struct {
 	Call         Call
 }
 
+// HandleEventFunc represents a handler for incoming events sent to the Python adapter, accepting an
+// event type and payload.
+type HandleEventFunc func(EventKind, *EventPayload)
+
+// Connect represents event data related to a connection to WhatsApp being established, or failing
+// to do so (based on the [Connect.Error] result).
+type Connect struct {
+	JID   string // The device JID given for this connection.
+	Error string // The connection error, if any.
+}
+
 // A Avatar represents a small image set for a Contact or Group.
 type Avatar struct {
 	ID  string // The unique ID for this avatar, used for persistent caching.
@@ -92,7 +108,8 @@ type PresenceKind int
 
 // The presences handled by the overarching session event handler.
 const (
-	PresenceAvailable PresenceKind = 1 + iota
+	PresenceUnknown PresenceKind = iota
+	PresenceAvailable
 	PresenceUnavailable
 )
 
@@ -126,7 +143,7 @@ type MessageKind int
 
 // The message types handled by the overarching session event handler.
 const (
-	MessagePlain MessageKind = 1 + iota
+	MessagePlain MessageKind = iota
 	MessageEdit
 	MessageRevoke
 	MessageReaction
@@ -145,10 +162,12 @@ type Message struct {
 	Body        string       // The plain-text message body. For attachment messages, this can be a caption.
 	Timestamp   int64        // The Unix timestamp denoting when this message was created.
 	IsCarbon    bool         // Whether or not this message concerns the gateway user themselves.
+	IsForwarded bool         // Whether or not the message was forwarded from another source.
 	ReplyID     string       // The unique message ID this message is in reply to, if any.
 	ReplyBody   string       // The full body of the message this message is in reply to, if any.
 	Attachments []Attachment // The list of file (image, video, etc.) attachments contained in this message.
 	Preview     Preview      // A short description for the URL provided in the message body, if any.
+	Location    Location     // The location metadata for messages, if any.
 	MentionJIDs []string     // A list of JIDs mentioned in this message, if any.
 	Receipts    []Receipt    // The receipt statuses for the message, typically provided alongside historical messages.
 	Reactions   []Message    // Reactions attached to message, typically provided alongside historical messages.
@@ -160,19 +179,41 @@ type Attachment struct {
 	MIME     string // The MIME type for attachment.
 	Filename string // The recommended file name for this attachment. May be an auto-generated name.
 	Caption  string // The user-provided caption, provided alongside this attachment.
-	Path     string // Local path to the file is stored on disk.
+	Data     []byte // Data for the attachment.
 
 	// Internal fields.
-	meta attachmentMetadata // Metadata specific to audio/video files, used in processing.
+	spec *media.Spec // Metadata specific to audio/video files, used in processing.
 }
 
+// PreviewKind represents different ways of previewingadditional data inline with messages.
+type PreviewKind int
+
+const (
+	PreviewPlain PreviewKind = iota
+	PreviewVideo
+)
+
 // A Preview represents a short description for a URL provided in a message body, as usually derived
 // from the content of the page pointed at.
 type Preview struct {
-	URL         string // The original (or canonical) URL this preview was generated for.
-	Title       string // The short title for the URL preview.
-	Description string // The (optional) long-form description for the URL preview.
-	ImagePath   string // The local path for the image associated with the URL.
+	Kind        PreviewKind // The kind of preview to show, defaults to plain URL preview.
+	URL         string      // The original (or canonical) URL this preview was generated for.
+	Title       string      // The short title for the URL preview.
+	Description string      // The (optional) long-form description for the URL preview.
+	Thumbnail   []byte      // The (optional) thumbnail image data.
+}
+
+// A Location represents additional metadata given to location messages.
+type Location struct {
+	Latitude  float64
+	Longitude float64
+	Accuracy  int
+	IsLive    bool
+
+	// Optional fields given for named locations.
+	Name    string
+	Address string
+	URL     string
 }
 
 // NewMessageEvent returns event data meant for [Session.propagateEvent] for the primive message
@@ -189,12 +230,14 @@ func newMessageEvent(client *whatsmeow.Client, evt *events.Message) (EventKind,
 		IsCarbon:  evt.Info.IsFromMe,
 	}
 
-	// Broadcast and status messages are currently not handled at all.
+	// Handle Broadcasts and Status Updates; currently, only non-carbon, non-status broadcast
+	// messages are handled as plain messages, as support for analogues is lacking in the XMPP
+	// world.
 	if evt.Info.Chat.Server == types.BroadcastServer {
-		return EventUnknown, nil
-	}
-
-	if evt.Info.IsGroup {
+		if evt.Info.Chat.User == types.StatusBroadcastJID.User || message.IsCarbon {
+			return EventUnknown, nil
+		}
+	} else if evt.Info.IsGroup {
 		message.GroupJID = evt.Info.Chat.ToNonAD().String()
 	} else if message.IsCarbon {
 		message.JID = evt.Info.Chat.ToNonAD().String()
@@ -227,6 +270,31 @@ func newMessageEvent(client *whatsmeow.Client, evt *events.Message) (EventKind,
 		return EventMessage, &EventPayload{Message: message}
 	}
 
+	// Handle location (static and live) message.
+	if l := evt.Message.GetLocationMessage(); l != nil {
+		message.Location = Location{
+			Latitude:  l.GetDegreesLatitude(),
+			Longitude: l.GetDegreesLongitude(),
+			Accuracy:  int(l.GetAccuracyInMeters()),
+			IsLive:    l.GetIsLive(),
+			Name:      l.GetName(),
+			Address:   l.GetAddress(),
+			URL:       l.GetURL(),
+		}
+		return EventMessage, &EventPayload{Message: message}
+	}
+
+	if l := evt.Message.GetLiveLocationMessage(); l != nil {
+		message.Body = l.GetCaption()
+		message.Location = Location{
+			Latitude:  l.GetDegreesLatitude(),
+			Longitude: l.GetDegreesLongitude(),
+			Accuracy:  int(l.GetAccuracyInMeters()),
+			IsLive:    true,
+		}
+		return EventMessage, &EventPayload{Message: message}
+	}
+
 	// Handle message attachments, if any.
 	if attach, context, err := getMessageAttachments(client, evt.Message); err != nil {
 		client.Log.Errorf("Failed getting message attachments: %s", err)
@@ -267,6 +335,7 @@ func getMessageWithContext(message Message, info *waE2E.ContextInfo) Message {
 
 	message.ReplyID = info.GetStanzaID()
 	message.OriginJID = info.GetParticipant()
+	message.IsForwarded = info.GetIsForwarded()
 
 	if q := info.GetQuotedMessage(); q != nil {
 		if qe := q.GetExtendedTextMessage(); qe != nil {
@@ -283,7 +352,8 @@ func getMessageWithContext(message Message, info *waE2E.ContextInfo) Message {
 // via WhatsApp. Any failures in retrieving any attachment will return an error immediately.
 func getMessageAttachments(client *whatsmeow.Client, message *waE2E.Message) ([]Attachment, *waE2E.ContextInfo, error) {
 	var result []Attachment
-	var context *waE2E.ContextInfo
+	var info *waE2E.ContextInfo
+	var convertSpec *media.Spec
 	var kinds = []whatsmeow.DownloadableMessage{
 		message.GetImageMessage(),
 		message.GetAudioMessage(),
@@ -299,7 +369,11 @@ func getMessageAttachments(client *whatsmeow.Client, message *waE2E.Message) ([]
 		case *waE2E.ImageMessage:
 			a.MIME, a.Caption = msg.GetMimetype(), msg.GetCaption()
 		case *waE2E.AudioMessage:
+			// Convert Opus-encoded voice messages to AAC-encoded audio, which has better support.
 			a.MIME = msg.GetMimetype()
+			if msg.GetPTT() {
+				convertSpec = &media.Spec{MIME: media.TypeM4A}
+			}
 		case *waE2E.VideoMessage:
 			a.MIME, a.Caption = msg.GetMimetype(), msg.GetCaption()
 		case *waE2E.DocumentMessage:
@@ -313,41 +387,204 @@ func getMessageAttachments(client *whatsmeow.Client, message *waE2E.Message) ([]
 			continue
 		}
 
-		// Set filename from SHA256 checksum and MIME type, if none is already set.
-		if a.Filename == "" {
-			a.Filename = fmt.Sprintf("%x%s", msg.GetFileSHA256(), extensionByType(a.MIME))
-		}
-
 		// Attempt to download and decrypt raw attachment data, if any.
 		data, err := client.Download(msg)
 		if err != nil {
 			return nil, nil, err
 		}
 
-		tmp, err := createTempFile(data)
-		if err != nil {
-			return nil, nil, fmt.Errorf("failed writing to temporary file: %w", err)
+		a.Data = data
+
+		// Convert incoming data if a specification has been given, ignoring any errors that occur.
+		if convertSpec != nil {
+			data, err = media.Convert(context.Background(), a.Data, convertSpec)
+			if err == nil {
+				a.Data, a.MIME = data, string(convertSpec.MIME)
+			}
+		}
+
+		// Set filename from SHA256 checksum and MIME type, if none is already set.
+		if a.Filename == "" {
+			a.Filename = fmt.Sprintf("%x%s", msg.GetFileSHA256(), extensionByType(a.MIME))
 		}
 
-		a.Path = tmp
 		result = append(result, a)
 	}
 
 	// Handle any contact vCard as attachment.
 	if c := message.GetContactMessage(); c != nil {
-		tmp, err := createTempFile([]byte(c.GetVcard()))
-		if err != nil {
-			return nil, nil, fmt.Errorf("Failed getting contact message: %w", err)
-		}
 		result = append(result, Attachment{
 			MIME:     "text/vcard",
 			Filename: c.GetDisplayName() + ".vcf",
-			Path:     tmp,
+			Data:     []byte(c.GetVcard()),
 		})
-		context = c.GetContextInfo()
+		info = c.GetContextInfo()
 	}
 
-	return result, context, nil
+	return result, info, nil
+}
+
+const (
+	// The MIME type used by voice messages on WhatsApp.
+	voiceMessageMIME = string(media.TypeOgg) + "; codecs=opus"
+	// the MIME type used by animated images on WhatsApp.
+	animatedImageMIME = "image/gif"
+
+	// The maximum image attachment size we'll attempt to process in any way, in bytes.
+	maxConvertImageSize = 1024 * 1024 * 10 // 10MiB
+	// The maximum audio/video attachment size we'll attempt to process in any way, in bytes.
+	maxConvertAudioVideoSize = 1024 * 1024 * 20 // 20MiB
+
+	// The maximum number of samples to return in media waveforms.
+	maxWaveformSamples = 64
+
+	// Default thumbnail width in pixels.
+	defaultThumbnailWidth = 100
+	previewThumbnailWidth = 250
+)
+
+var (
+	// Default target specification for voice messages.
+	voiceMessageSpec = media.Spec{
+		MIME:            media.MIMEType(voiceMessageMIME),
+		AudioBitRate:    64,
+		AudioChannels:   1,
+		AudioSampleRate: 48000,
+		StripMetadata:   true,
+	}
+
+	// Default target specification for generic audio messages.
+	audioMessageSpec = media.Spec{
+		MIME:            media.TypeM4A,
+		AudioBitRate:    160,
+		AudioSampleRate: 44100,
+	}
+
+	// Default target specification for video messages with inline preview.
+	videoMessageSpec = media.Spec{
+		MIME:             media.TypeMP4,
+		AudioBitRate:     160,
+		AudioSampleRate:  44100,
+		VideoFilter:      "pad=ceil(iw/2)*2:ceil(ih/2)*2",
+		VideoFrameRate:   25,
+		VideoPixelFormat: "yuv420p",
+		StripMetadata:    true,
+	}
+
+	// Default target specification for image messages with inline preview.
+	imageMessageSpec = media.Spec{
+		MIME:         media.TypeJPEG,
+		ImageQuality: 85,
+	}
+)
+
+// ConvertAttachment attempts to process a given attachment from a less-supported type to a
+// canonically supported one; for example, from `image/png` to `image/jpeg`.
+//
+// Decisions about which MIME types to convert to are based on the concrete MIME type inferred from
+// the file itself, and care is taken to conform to WhatsApp semantics for the given input MIME
+// type.
+//
+// If the input MIME type is unknown, or conversion is impossible, the given attachment is not
+// changed.
+func convertAttachment(attach *Attachment) error {
+	var detectedMIME string
+	if t, _ := filetype.Match(attach.Data); t != filetype.Unknown {
+		detectedMIME = t.MIME.Value
+		if attach.MIME == "" || attach.MIME == "application/octet-stream" {
+			attach.MIME = detectedMIME
+		}
+	}
+
+	var spec media.Spec
+	var ctx = context.Background()
+
+	switch detectedMIME {
+	case "image/png", "image/webp":
+		// Convert common image formats to JPEG for inline preview.
+		if len(attach.Data) > maxConvertImageSize {
+			return fmt.Errorf("attachment size %d exceeds maximum of %d", len(attach.Data), maxConvertImageSize)
+		}
+
+		spec = imageMessageSpec
+	case "image/gif":
+		// Convert animated GIFs to MP4, as required by WhatsApp.
+		if len(attach.Data) > maxConvertImageSize {
+			return fmt.Errorf("attachment size %d exceeds maximum of %d", len(attach.Data), maxConvertImageSize)
+		}
+
+		img, err := gif.DecodeAll(bytes.NewReader(attach.Data))
+		if err != nil {
+			return fmt.Errorf("unable to decode GIF attachment")
+		} else if len(img.Image) == 1 {
+			spec = imageMessageSpec
+		} else {
+			spec = videoMessageSpec
+			var t float64
+			for d := range img.Delay {
+				t += float64(d) / 100
+			}
+			spec.ImageFrameRate = int(float64(len(img.Image)) / t)
+		}
+	case "audio/m4a", "audio/mp4":
+		if len(attach.Data) > maxConvertAudioVideoSize {
+			return fmt.Errorf("attachment size %d exceeds maximum of %d", len(attach.Data), maxConvertAudioVideoSize)
+		}
+
+		spec = voiceMessageSpec
+
+		if s, err := media.GetSpec(ctx, attach.Data); err == nil {
+			attach.spec = s
+			if s.AudioCodec == "alac" {
+				// Don't attempt to process lossless files at all, as it's assumed that the sender
+				// wants to retain these characteristics. Since WhatsApp will try (and likely fail)
+				// to process this as an audio message anyways, set a unique MIME type.
+				attach.MIME = "application/octet-stream"
+				return nil
+			}
+		}
+	case "audio/ogg":
+		if len(attach.Data) > maxConvertAudioVideoSize {
+			return fmt.Errorf("attachment size %d exceeds maximum of %d", len(attach.Data), maxConvertAudioVideoSize)
+		}
+
+		spec = audioMessageSpec
+		if s, err := media.GetSpec(ctx, attach.Data); err == nil {
+			attach.spec = s
+			if s.AudioCodec == "opus" {
+				// Assume that Opus-encoded Ogg files are meant to be voice messages, and re-encode
+				// them as such for WhatsApp.
+				spec = voiceMessageSpec
+			}
+		}
+	case "video/mp4", "video/webm":
+		if len(attach.Data) > maxConvertAudioVideoSize {
+			return fmt.Errorf("attachment size %d exceeds maximum of %d", len(attach.Data), maxConvertAudioVideoSize)
+		}
+
+		spec = videoMessageSpec
+
+		if s, err := media.GetSpec(ctx, attach.Data); err == nil {
+			attach.spec = s
+			// Try to see if there's a video stream for ostensibly video-related MIME types, as
+			// these are some times misdetected as such.
+			if s.VideoWidth == 0 && s.VideoHeight == 0 && s.AudioSampleRate > 0 && s.Duration > 0 {
+				spec = voiceMessageSpec
+			}
+		}
+	default:
+		// Detected source MIME not in list we're willing to convert, move on without error.
+		return nil
+	}
+
+	// Convert attachment between file-types, if source MIME matches the known list of convertable types.
+	data, err := media.Convert(ctx, attach.Data, &spec)
+	if err != nil {
+		return fmt.Errorf("failed converting attachment: %w", err)
+	}
+
+	attach.Data, attach.MIME = data, string(spec.MIME)
+	return nil
 }
 
 // KnownMediaTypes represents MIME type to WhatsApp media types known to be handled by WhatsApp in a
@@ -366,24 +603,23 @@ var knownMediaTypes = map[string]whatsmeow.MediaType{
 // specific format; in addition, certain MIME types may be automatically converted to a
 // well-supported type via FFmpeg (if available).
 func uploadAttachment(client *whatsmeow.Client, attach *Attachment) (*waE2E.Message, error) {
+	var ctx = context.Background()
 	var originalMIME = attach.MIME
+
 	if err := convertAttachment(attach); err != nil {
 		client.Log.Warnf("failed to auto-convert attachment: %s", err)
 	}
 
-	mediaType := knownMediaTypes[strings.Split(attach.MIME, ";")[0]]
+	mediaType := knownMediaTypes[getBaseMediaType(attach.MIME)]
 	if mediaType == "" {
 		mediaType = whatsmeow.MediaDocument
 	}
 
-	data, err := os.ReadFile(attach.Path)
-	if err != nil {
-		return nil, err
-	} else if len(data) == 0 {
+	if len(attach.Data) == 0 {
 		return nil, fmt.Errorf("attachment file contains no data")
 	}
 
-	upload, err := client.Upload(context.Background(), data, mediaType)
+	upload, err := client.Upload(ctx, attach.Data, mediaType)
 	if err != nil {
 		return nil, err
 	}
@@ -399,12 +635,19 @@ func uploadAttachment(client *whatsmeow.Client, attach *Attachment) (*waE2E.Mess
 				Mimetype:      &attach.MIME,
 				FileEncSHA256: upload.FileEncSHA256,
 				FileSHA256:    upload.FileSHA256,
-				FileLength:    ptrTo(uint64(len(data))),
+				FileLength:    ptrTo(uint64(len(attach.Data))),
 			},
 		}
+		t, err := media.Convert(ctx, attach.Data, &media.Spec{MIME: media.TypeJPEG, ImageWidth: defaultThumbnailWidth})
+		if err != nil {
+			client.Log.Warnf("failed generating attachment thumbnail: %s", err)
+		} else {
+			message.ImageMessage.JPEGThumbnail = t
+		}
 	case whatsmeow.MediaAudio:
-		if attach.meta == (attachmentMetadata{}) {
-			if err = populateAttachmentMetadata(attach); err != nil {
+		spec := attach.spec
+		if spec == nil {
+			if spec, err = media.GetSpec(ctx, attach.Data); err != nil {
 				client.Log.Warnf("failed fetching attachment metadata: %s", err)
 			}
 		}
@@ -416,21 +659,25 @@ func uploadAttachment(client *whatsmeow.Client, attach *Attachment) (*waE2E.Mess
 				Mimetype:      &attach.MIME,
 				FileEncSHA256: upload.FileEncSHA256,
 				FileSHA256:    upload.FileSHA256,
-				FileLength:    ptrTo(uint64(len(data))),
-				Seconds:       ptrTo(uint32(attach.meta.duration.Seconds())),
+				FileLength:    ptrTo(uint64(len(attach.Data))),
+				Seconds:       ptrTo(uint32(spec.Duration.Seconds())),
 			},
 		}
 		if attach.MIME == voiceMessageMIME {
 			message.AudioMessage.PTT = ptrTo(true)
-			if wave, err := getAttachmentWaveform(attach); err != nil {
-				client.Log.Warnf("failed generating attachment waveform: %s", err)
-			} else {
-				message.AudioMessage.Waveform = wave
+			if spec != nil {
+				w, err := media.GetWaveform(ctx, attach.Data, spec, maxWaveformSamples)
+				if err != nil {
+					client.Log.Warnf("failed generating attachment waveform: %s", err)
+				} else {
+					message.AudioMessage.Waveform = w
+				}
 			}
 		}
 	case whatsmeow.MediaVideo:
-		if attach.meta == (attachmentMetadata{}) {
-			if err = populateAttachmentMetadata(attach); err != nil {
+		spec := attach.spec
+		if spec == nil {
+			if spec, err = media.GetSpec(ctx, attach.Data); err != nil {
 				client.Log.Warnf("failed fetching attachment metadata: %s", err)
 			}
 		}
@@ -442,15 +689,17 @@ func uploadAttachment(client *whatsmeow.Client, attach *Attachment) (*waE2E.Mess
 				Mimetype:      &attach.MIME,
 				FileEncSHA256: upload.FileEncSHA256,
 				FileSHA256:    upload.FileSHA256,
-				FileLength:    ptrTo(uint64(len(data))),
-				Seconds:       ptrTo(uint32(attach.meta.duration.Seconds())),
-				Width:         ptrTo(uint32(attach.meta.width)),
-				Height:        ptrTo(uint32(attach.meta.height)),
-			}}
-		if thumb, err := getAttachmentThumbnail(attach); err != nil {
+				FileLength:    ptrTo(uint64(len(attach.Data))),
+				Seconds:       ptrTo(uint32(spec.Duration.Seconds())),
+				Width:         ptrTo(uint32(spec.VideoWidth)),
+				Height:        ptrTo(uint32(spec.VideoHeight)),
+			},
+		}
+		t, err := media.GetThumbnail(ctx, attach.Data, defaultThumbnailWidth, 0)
+		if err != nil {
 			client.Log.Warnf("failed generating attachment thumbnail: %s", err)
 		} else {
-			message.VideoMessage.JPEGThumbnail = thumb
+			message.VideoMessage.JPEGThumbnail = t
 		}
 		if originalMIME == animatedImageMIME {
 			message.VideoMessage.GifPlayback = ptrTo(true)
@@ -464,7 +713,7 @@ func uploadAttachment(client *whatsmeow.Client, attach *Attachment) (*waE2E.Mess
 				Mimetype:      &attach.MIME,
 				FileEncSHA256: upload.FileEncSHA256,
 				FileSHA256:    upload.FileSHA256,
-				FileLength:    ptrTo(uint64(len(data))),
+				FileLength:    ptrTo(uint64(len(attach.Data))),
 				FileName:      &attach.Filename,
 			}}
 	}
@@ -476,6 +725,7 @@ func uploadAttachment(client *whatsmeow.Client, attach *Attachment) (*waE2E.Mess
 var knownExtensions = map[string]string{
 	"image/jpeg": ".jpg",
 	"audio/ogg":  ".oga",
+	"audio/mp4":  ".m4a",
 	"video/mp4":  ".mp4",
 }
 
@@ -492,6 +742,11 @@ func extensionByType(typ string) string {
 	return ".bin"
 }
 
+// GetBaseMediaType returns the media type without any additional parameters.
+func getBaseMediaType(typ string) string {
+	return strings.SplitN(typ, ";", 2)[0]
+}
+
 // NewEventFromHistory returns event data meant for [Session.propagateEvent] for the primive history
 // message given. Currently, only events related to group-chats will be handled, due to uncertain
 // support for history back-fills on 1:1 chats.
@@ -618,7 +873,8 @@ type ChatStateKind int
 
 // The chat states handled by the overarching session event handler.
 const (
-	ChatStateComposing ChatStateKind = 1 + iota
+	ChatStateUnknown ChatStateKind = iota
+	ChatStateComposing
 	ChatStatePaused
 )
 
@@ -652,7 +908,8 @@ type ReceiptKind int
 
 // The delivery receipts handled by the overarching session event handler.
 const (
-	ReceiptDelivered ReceiptKind = 1 + iota
+	ReceiptUnknown ReceiptKind = iota
+	ReceiptDelivered
 	ReceiptRead
 )
 
@@ -682,12 +939,9 @@ func newReceiptEvent(evt *events.Receipt) (EventKind, *EventPayload) {
 		return EventUnknown, nil
 	}
 
-	// Receipts for broadcast and status messages are currently not handled at all.
 	if evt.MessageSource.Chat.Server == types.BroadcastServer {
-		return EventUnknown, nil
-	}
-
-	if evt.MessageSource.IsGroup {
+		receipt.JID = evt.MessageSource.BroadcastListOwner.ToNonAD().String()
+	} else if evt.MessageSource.IsGroup {
 		receipt.GroupJID = evt.MessageSource.Chat.ToNonAD().String()
 	} else if receipt.IsCarbon {
 		receipt.JID = evt.MessageSource.Chat.ToNonAD().String()