Recherche avancée

Sur d’autres sites (12686)

• Can't find error in function for changing sampling rate [closed]

  12 septembre 2024, par leeeeeeeeess

  I have function for changing sampling rate of audio (only one channel) :

  


  int change_sampling_rate(float *audio_input, int input_sample_rate, int output_sample_rate, int input_num_of_samples, float **audio_output, int *result_num_of_samples) 


  


  When I run tests on time lag between two files (mp3) with different sampling rates, it gives answer that differs on about 15-20 ms with right answer. Can anybody, please, help me find mistakes in the code ?

  


  For example, I have two audios : [audio_1] (https://jmp.sh/s/USFPaGnHXVuKFVYarYpm) and [audio_2] (https://jmp.sh/s/jbmWbPTwkdDujAocmi56) - second audio is just a sample of first. The answer should be 35264 ms, but my function gives 35249 ms :(

  


• Can't find error in function for changing sampling rate

  29 avril 2024, par kitty uwu

  I have function for changing sampling rate of audio (only one channel) :

  


  int change_sampling_rate(float *audio_input, int input_sample_rate, int output_sample_rate, int input_num_of_samples, float **audio_output, int *result_num_of_samples) {
    AVChannelLayout src_ch_layout = AV_CHANNEL_LAYOUT_MONO;
    AVChannelLayout dst_ch_layout = AV_CHANNEL_LAYOUT_MONO;

    struct SwrContext *swr_ctx;
    swr_ctx = swr_alloc();
    int ret;
    if (!swr_ctx) {
        fprintf(stderr, "Could not allocate resampler context\n");
        ret = AVERROR(ENOMEM);
    }

    av_opt_set_chlayout(swr_ctx, "in_chlayout",    &src_ch_layout, 0);
    av_opt_set_int(swr_ctx, "in_sample_rate",       input_sample_rate, 0);
    av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", AV_SAMPLE_FMT_FLT, 0);

    av_opt_set_chlayout(swr_ctx, "out_chlayout",    &dst_ch_layout, 0);
    av_opt_set_int(swr_ctx, "out_sample_rate",       output_sample_rate, 0);
    av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", AV_SAMPLE_FMT_FLT, 0);

    if ((ret = swr_init(swr_ctx)) < 0) {
        fprintf(stderr, "Failed to initialize the resampling context\n");
        return -1;
    }

    int output_samples_count = av_rescale_rnd(swr_get_delay(swr_ctx, input_sample_rate) + input_num_of_samples, output_sample_rate, input_sample_rate, AV_ROUND_UP);
    uint8_t **resampled_data = NULL;
    if (av_samples_alloc_array_and_samples(&resampled_data, NULL, 1, output_samples_count, AV_SAMPLE_FMT_FLT, 0) < 0) {
        fprintf(stderr, "Could not allocate resampled data\n");
        swr_free(&swr_ctx);
        return -1;
    }

    const uint8_t *in_samples[1] = {(const uint8_t *)audio_input};
    int frame_count = swr_convert(swr_ctx, resampled_data, output_samples_count, in_samples, input_num_of_samples);

    if (frame_count < 0) {
        fprintf(stderr, "Error while resampling\n");
        av_freep(&resampled_data[0]);
        free(resampled_data);
        swr_free(&swr_ctx);
        return -1;
    }

    *audio_output = (float *) malloc(frame_count * sizeof(float));
    if (!*audio_output) {
        fprintf(stderr, "Could not allocate memory for output\n");
        av_freep(&resampled_data[0]);
        free(resampled_data);
        swr_free(&swr_ctx);
        return -1;
    }

    memcpy(*audio_output, resampled_data[0], frame_count * sizeof(float));

    *result_num_of_samples = frame_count;
    av_freep(&resampled_data[0]);
    swr_free(&swr_ctx);
    return SUCCESS;
}


  


  When I run tests on time lag between two files (mp3) with different sampling rates, it gives answer that differs on about 15-20 ms with right answer. Can anybody, please, help me find mistakes in the code ?

  


  For example, I have two audios : [audio_1] (https://jmp.sh/s/USFPaGnHXVuKFVYarYpm) and [audio_2] (https://jmp.sh/s/jbmWbPTwkdDujAocmi56) - second audio is just a sample of first. The answer should be 35264 ms, but my function gives 35249 ms :(

  


• Error : Cannot find ffmpeg in firebase cloud function

  6 novembre 2024, par Ahmed Wagdi

  i'm trying to compress some uploaded files to firebase storage .. using firebase cloud functions but it give me the error Error: Cannot find ffmpeg

  


  here is my function :

  


  const functions = require("firebase-functions");
const admin = require("firebase-admin");
const ffmpeg = require("fluent-ffmpeg");
const ffmpegStatic = require("ffmpeg-static");
const axios = require("axios");

// const {onSchedule} = require("firebase-functions/v2/scheduler");

admin.initializeApp();

// Ensure fluent-ffmpeg uses the binary
ffmpeg.setFfmpegPath(ffmpegStatic.path);

const db = admin.firestore();
const bucket = admin.storage().bucket();
const fs = require("fs");
const downloadVideo = async (url, outputPath) => {
  const response = await axios.get(url, {responseType: "stream"});
  const writer = fs.createWriteStream(outputPath);
  response.data.pipe(writer);
  return new Promise((resolve, reject) => {
    writer.on("finish", () => resolve(outputPath));
    writer.on("error", reject);
  });
};

const compressVideo = (videoFullPath, outputFileName, targetSize) => {
  return new Promise((resolve, reject) => {
    ffmpeg.ffprobe(videoFullPath, (err, metadata) => {
      if (err) return reject(err);
      const duration = parseFloat(metadata.format.duration);
      const targetTotalBitrate =
      (targetSize * 1024 * 8) / (1.073741824 * duration);

      let audioBitrate =
      metadata.streams.find((s) => s.codec_type === "audio").bit_rate;
      if (10 * audioBitrate > targetTotalBitrate) {
        audioBitrate = targetTotalBitrate / 10;
      }

      const videoBitrate = targetTotalBitrate - audioBitrate;
      ffmpeg(videoFullPath)
          .output(outputFileName)
          .videoCodec("libx264")
          .audioCodec("aac")
          .videoBitrate(videoBitrate)
          .audioBitrate(audioBitrate)
          .on("end", resolve)
          .on("error", reject)
          .run();
    });
  });
};

const uploadVideoWithResumableUpload = (filePath, destinationBlobName) => {
  const blob = bucket.file(destinationBlobName);
  const options = {resumable: true, validation: "crc32c"};
  return blob.createWriteStream(options).end(fs.readFileSync(filePath));
};

exports.processLessonsOnDemand =
functions.https.onRequest({timeoutSeconds: 3600, memory: "2GB"}
    , async (context) => {
      console.log("Fetching lessons from Firestore...");
      const lessonsRef = db.collection("leassons");
      const lessonsSnapshot = await lessonsRef.get();

      if (lessonsSnapshot.empty) {
        console.log("No lessons found in Firestore.");
        return; // Exit if no lessons are available
      }

      const lessonDoc = lessonsSnapshot.docs[0]; // Get the first document
      const lessonData = lessonDoc.data();

      if (lessonData.shrinked) {
        console.log(
            `Skipping lesson ID ${lessonDoc.id} as it's already shrunk.`,
        );
        return; // Exit if the first lesson is already shrunk
      }

      const videoURL = lessonData.videoURL;
      if (!videoURL) {
        console.log(
            `No video URL for lesson ID: ${lessonDoc.id}. Skipping...`,
        );
        return; // Exit if no video URL is available
      }

      const tempVideoPath = "/tmp/temp_video.mp4";

      try {
        await downloadVideo(videoURL, tempVideoPath);

        const targetSize = (fs.statSync(tempVideoPath).size * 0.30) / 1024;
        const outputCompressedVideo = `/tmp/compressed_${lessonDoc.id}.mp4`;

        await compressVideo(tempVideoPath, outputCompressedVideo, targetSize);

        await uploadVideoWithResumableUpload(
            outputCompressedVideo,
            `compressed_videos/compressed_${lessonDoc.id}.mp4`,
        );

        const newVideoURL = `https://storage.googleapis.com/${bucket.name}/compressed_videos/compressed_${lessonDoc.id}.mp4`;

        const oldVideoPath = videoURL.replace(`https://storage.googleapis.com/${bucket.name}/`, "");
        const oldBlob = bucket.file(oldVideoPath);
        await oldBlob.delete();

        await lessonsRef.doc(lessonDoc.id).update({
          videoURL: newVideoURL,
          shrinked: true,
        });

        console.log(`Processed lesson ID: ${lessonDoc.id}`);
        fs.unlinkSync(tempVideoPath); // Clean up temporary files
        fs.unlinkSync(outputCompressedVideo); // Clean up compressed file
      } catch (error) {
        console.error(`Error processing lesson ID ${lessonDoc.id}:`, error);
      }
    });