Recherche avancée

Sur d’autres sites (7677)

• Node.js Stream Mp3 to http without having to save file

  10 janvier 2019, par user2758113

  I am trying to stream just audio from a youtube link straight to http with node.js.

  My code looks like this, I am using express 4.0.

  var express = require('express');
  
  var router = express.Router();
  
  var ytdl = require('ytdl');
  
  var ffmpeg = require('fluent-ffmpeg');
  
  var fs = require('fs');
  
  
  
  router.get('/', function(req, res) {
  
  
  
    var url = 'https://www.youtube.com/watch?v=GgcHlZsOgQo';
  
    var video = ytdl(url)
  
  
  
    res.set({
  
        "Content-Type": "audio/mpeg"
  
    })
  
  
  
    new ffmpeg({source: video})
  
        .toFormat('mp3')
  
        .writeToStream(res, function(data, err) {
  
          if (err) console.log(err)
  
        })
  
  
  
  });
  
  
  
  module.exports = router;

  Now, I’m able to stream the video’s audio to the response if I save the file then pipe it to the response, but I’d rather try to figure out some way to go from downloading to ffmpeg to response.

  Not sure if this is possible. The main goal is to keep it as light weight as possible, and not have to read from files.

  I’ve seen this code which is essentially what I’d like to do minus the saving to a file part.

  

• FFmpeg - Putting segments of same video together

  11 juin 2020, par parthlr

  I am trying to take different segments of the same video and put them together in a new video, essentially cutting out the parts in between the segments. I have built on the answer to this question that I asked before to try and do this. I figured that with putting together segments of the same video, I would have to subtract the first dts of the segment in order for it to start perfectly after the previous segment.

  



  However, when I attempt to do this, I once again get the error Application provided invalid, non monotonically increasing dts to muxer in stream 0. This error is both for stream 0 and 1 (video and audio). It seems that I receive this error for only the first packet in each segment.

  



  On top of that, the output file plays the segments in the correct order, but the video freezes for about a second when there is a transition from one segment to the next. I have a feeling that this is because the dts of each packet is not set properly and as a result the segment is encoded about a second after it should be.

  



  This is the code that I have written :

  



  Video and ClipSequence structs :

  



  typedef struct Video {
    char* filename;
    AVFormatContext* inputContext;
    AVFormatContext* outputContext;
    AVCodec* videoCodec;
    AVCodec* audioCodec;
    AVStream* inputStream;
    AVStream* outputStream;
    AVCodecContext* videoCodecContext_I; // Input
    AVCodecContext* audioCodecContext_I; // Input
    AVCodecContext* videoCodecContext_O; // Output
    AVCodecContext* audioCodecContext_O; // Output
    int videoStream;
    int audioStream;
    SwrContext* swrContext;
} Video;

typedef struct ClipSequence {
    VideoList* videos;
    AVFormatContext* outputContext;
    AVStream* outputStream;
    int64_t lastpts, lastdts;
    int64_t currentpts, currentdts;
} ClipSequence;


  



  Decoding and encoding (same for audio) :

  



  int decodeVideoSequence(ClipSequence* sequence, Video* video, AVPacket* packet) {
    int response = avcodec_send_packet(video->videoCodecContext_I, packet);
    if (response < 0) {
        printf("[ERROR] Failed to send video packet to decoder\n");
        return response;
    }
    AVFrame* frame = av_frame_alloc();
    while (response >= 0) {
        response = avcodec_receive_frame(video->videoCodecContext_I, frame);
        if (response == AVERROR(EAGAIN) || response == AVERROR_EOF) {
            break;
        } else if (response < 0) {
            printf("[ERROR] Failed to receive video frame from decoder\n");
            return response;
        }
        if (response >= 0) {
            // Do stuff and encode

            // Subtract first dts from the current dts
            sequence->v_currentdts = packet->dts - sequence->v_firstdts;

            if (encodeVideoSequence(sequence, video, frame) < 0) {
                printf("[ERROR] Failed to encode new video\n");
                return -1;
            }
        }
        av_frame_unref(frame);
    }
    return 0;
}

int encodeVideoSequence(ClipSequence* sequence, Video* video, AVFrame* frame) {
    AVPacket* packet = av_packet_alloc();
    if (!packet) {
        printf("[ERROR] Could not allocate memory for video output packet\n");
        return -1;
    }
    int response = avcodec_send_frame(video->videoCodecContext_O, frame);
    if (response < 0) {
        printf("[ERROR] Failed to send video frame for encoding\n");
        return response;
    }
    while (response >= 0) {
        response = avcodec_receive_packet(video->videoCodecContext_O, packet);
        if (response == AVERROR(EAGAIN) || response == AVERROR_EOF) {
            break;
        } else if (response < 0) {
            printf("[ERROR] Failed to receive video packet from encoder\n");
            return response;
        }
        // Update dts and pts of video
        packet->duration = VIDEO_PACKET_DURATION;
        int64_t cts = packet->pts - packet->dts;
        packet->dts = sequence->v_currentdts + sequence->v_lastdts + packet->duration;
        packet->pts = packet->dts + cts;
        packet->stream_index = video->videoStream;
        response = av_interleaved_write_frame(sequence->outputContext, packet);
        if (response < 0) {
            printf("[ERROR] Failed to write video packet\n");
            break;
        }
    }
    av_packet_unref(packet);
    av_packet_free(&packet);
    return 0;
}


  



  Cutting the video from a specific range of frames :

  



  int cutVideo(ClipSequence* sequence, Video* video, int startFrame, int endFrame) {
    printf("[WRITE] Cutting video from frame %i to %i\n", startFrame, endFrame);
    // Seeking stream is set to 0 by default and for testing purposes
    if (findPacket(video->inputContext, startFrame, 0) < 0) {
        printf("[ERROR] Failed to find packet\n");
    }
    AVPacket* packet = av_packet_alloc();
    if (!packet) {
        printf("[ERROR] Could not allocate packet for cutting video\n");
        return -1;
    }
    int currentFrame = startFrame;
    bool v_firstframe = true;
    bool a_firstframe = true;
    while (av_read_frame(video->inputContext, packet) >= 0 && currentFrame <= endFrame) {
        if (packet->stream_index == video->videoStream) {
            // Only count video frames since seeking is based on 60 fps video frames
            currentFrame++;
            // Store the first dts
            if (v_firstframe) {
                v_firstframe = false;
                sequence->v_firstdts = packet->dts;
            }
            if (decodeVideoSequence(sequence, video, packet) < 0) {
                printf("[ERROR] Failed to decode and encode video\n");
                return -1;
            }
        } else if (packet->stream_index == video->audioStream) {
            if (a_firstframe) {
                a_firstframe = false;
                sequence->a_firstdts = packet->dts;
            }
            if (decodeAudioSequence(sequence, video, packet) < 0) {
                printf("[ERROR] Failed to decode and encode audio\n");
                return -1;
            }
        }
        av_packet_unref(packet);
    }
    sequence->v_lastdts += sequence->v_currentdts;
    sequence->a_lastdts += sequence->a_currentdts;
    return 0;
}


  



  Finding correct place in video to start :

  



  int findPacket(AVFormatContext* inputContext, int frameIndex, int stream) {
    int64_t timebase;
    if (stream < 0) {
        timebase = AV_TIME_BASE;
    } else if (stream >= 0) {
        timebase = (inputContext->streams[stream]->time_base.den) / inputContext->streams[stream]->time_base.num;
    }
    int64_t seekTarget = timebase * frameIndex / VIDEO_DEFAULT_FPS;
    if (av_seek_frame(inputContext, stream, seekTarget, AVSEEK_FLAG_ANY) < 0) {
        printf("[ERROR] Failed to find keyframe from frame index %i\n", frameIndex);
        return -1;
    }
    return 0;
}


  



  UPDATE :

  



  I have achieved the desired result, but not in the way that I wanted to. I took each segment and encoded them to a separate video file. Then, I took those separate videos and encoded them into one sequence of videos. However, this isn't the optimal method of achieving what I want. It's definitely a lot slower and I have written a lot more code than I believe I should have. I still don't know what the issue is to my original problem, and I would greatly appreciate any help.

  


• Revision e85eaf6acd : Remove redundant mode update in sub8x8 decoding The probability model used to c

  24 septembre 2013, par Jingning Han

  Changed Paths :
   Modify /vp9/decoder/vp9_decodemv.c

  
  
  Remove redundant mode update in sub8x8 decoding

  The probability model used to code prediction mode is conditioned
  on the immediate above and left 8x8 blocks' prediction modes. When
  the above/left block is coded in sub8x8 mode, we use the prediction
  mode of the bottom-right sub8x8 block as the reference to generate
  the context.

  This commit moves the update of mbmi.mode out of the sub8x8 decoding
  loop, hence removing redundant update steps and keeping the bottom-
  right block's mode for the decoding process of next blocks.

  Change-Id : I1e8d749684d201c1a1151697621efa5d569218b6