Howto sent a video as video rounded (Videonote)

[tilibougnia]

I tried this :

`let media = await new Api.InputMediaUploadedDocument({
file: await client.uploadFile({
file: new CustomFile(
"video.mp4",
statSync("./video.mp4").size,
"./video.mp4"
),
workers: 1,
}),
attributes: [new Api.DocumentAttributeVideo({
duration: 11.0,
h: 3,
w: 3,
roundMessage: true,
supportsStreaming: true,
})],
mimeType: 'video/mp4',
//ttlSeconds: 5,
})

const resultsent = await client.invoke(
new Api.messages.SendMedia({
peer: "me",
media: await media,
message: "ss",
randomId: BigInt("-4156887774564"),
noforwards: true,
//scheduleDate: 43,
//sendAs: "username",
})
`

But the video has always send as a gif and not a video, and moreover is not rounded...

Can you help me ?

[caffeinum]

@tilibougnia you should re-format video to exactly 512x512, use ffmpeg or some other tool

[caffeinum]

this worked for me (mostly ai-generated, so don't read too much into it)

import { TelegramClient } from "telegram";
import { CustomFile } from "telegram/client/uploads";
import { Api } from "telegram";
import { promises as fs } from "fs";
import { exec } from "child_process";
import { promisify } from "util";
import { tmpdir } from "os";
import { join } from "path";

const execAsync = promisify(exec);

async function getVideoDimensions(videoPath: string): Promise<{ width: number; height: number; duration: number }> {
  try {
    const { stdout } = await execAsync(
      `ffprobe -v error -select_streams v:0 -show_entries stream=width,height,duration -of csv=p=0 "${videoPath}"`
    );
    const [width, height, duration] = stdout.trim().split(",").map(Number);
    return { width, height, duration };
  } catch (error) {
    console.warn("⚠ ffprobe not available, using default dimensions (512x512, 1s)");
    return { width: 512, height: 512, duration: 1 };
  }
}

async function convertToRoundVideo(inputPath: string): Promise<{ path: string; duration: number; cleanup: () => Promise<void> }> {
  const tempPath = join(tmpdir(), `round-video-${Date.now()}.mp4`);
  
  // crop center square first, then scale to 512x512
  // crop=min(iw\,ih):min(iw\,ih) crops the center square based on smallest dimension
  await execAsync(
    `ffmpeg -i "${inputPath}" -vf "crop=min(iw\\,ih):min(iw\\,ih),scale=512:512" -c:v libx264 -preset fast -crf 22 -c:a aac -b:a 128k "${tempPath}" -y`
  );
  
  const { duration } = await getVideoDimensions(tempPath);
  
  return {
    path: tempPath,
    duration,
    cleanup: async () => {
      try {
        await fs.unlink(tempPath);
      } catch (e) {
        // ignore cleanup errors
      }
    }
  };
}

/**
 * send a round video message to a telegram user or chat
 * automatically converts video to 512x512 square format
 */
export async function sendRoundVideo(
  client: TelegramClient,
  username: string,
  videoPath: string
): Promise<number | undefined> {
  let convertedVideo: { path: string; duration: number; cleanup: () => Promise<void> } | null = null;

  try {
    // convert video to 512x512 square format
    convertedVideo = await convertToRoundVideo(videoPath);
    
    // read converted file stats
    const stats = await fs.stat(convertedVideo.path);
    const fileName = videoPath.split("/").pop() || "video.mp4";

    // create custom file
    const file = new CustomFile(fileName, stats.size, convertedVideo.path);

    // upload file
    const uploadedFile = await client.uploadFile({
      file: file,
      workers: 1,
    });

    // get peer entity
    const peer = await client.getInputEntity(username);

    // send using low-level API with InputMediaUploadedDocument
    const result = await client.invoke(
      new Api.messages.SendMedia({
        peer: peer,
        media: new Api.InputMediaUploadedDocument({
          file: uploadedFile,
          mimeType: "video/mp4",
          attributes: [
            new Api.DocumentAttributeVideo({
              roundMessage: true,
              w: 512,
              h: 512,
              duration: convertedVideo.duration,
              supportsStreaming: false,
            }),
          ],
        }),
        message: "",
      })
    );

    // extract message id
    const updates = (result as any).updates;
    const messageId = updates?.find((u: any) => u.className === 'UpdateMessageID')?.id;
    
    return messageId;
  } finally {
    // cleanup converted video
    if (convertedVideo) {
      await convertedVideo.cleanup();
    }
  }
}