Recherche avancée

Sur d’autres sites (6261)

• ffmpeg blured bars on vertical movie - Error while opening encoder

  14 mars 2021, par hexedecimal

  I'm trying to use ffmpeg to prepare a mp4 file which is vertical recorded for upload to youtube.
(on a synology DS220+)
In the output file I want to have no black bars on the side but blured sodebars of the movie itself.
This I'm trying to do whit this code (in the end I want to automate this process, but maybe there is a better way to do this) :

  


  ffmpeg -i input.mp4 -lavfi "[0:v]scale=1920*2:1080*2,boxblur=luma_radius=min(h\,w)/20:luma_power=1:chroma_radius=min(cw\,ch)/20:chroma_power=1[bg];[0:v]scale=-1:1080[ov];[bg][ov]overlay=(W-w)/2:(H-h)/2,crop=w=1920:h=1080" output.mp4 


  


  unfortunaly i get a error message :

  


  Error while opening encoder for output stream #0:1 - maybe incorrect parameters such as bit_rate, rate, width or height


  


  In mine search on the internet I have tried multiple ways to get this done but whit all the same error result.
This was making me think that the ffmpeg install is faulty or I was trying wrong code.

  


  Could somebody help me whit this "project"

  


  full responce below :

  


  username@ip:/volume1/location$ ffmpeg -i input.mp4 -lavfi "[0:v]scale=1920*2:1080*2,boxblur=luma_radius=min(h\,w)/20:luma_power=1:chroma_radius=min(cw\,ch)/20:chroma_power=1[bg];[0:v]scale=-1:1080[ov];[bg][ov]overlay=(W-w)/2:(H-h)/2,crop=w=1920:h=1080" output.mp4
ffmpeg version 2.7.7 Copyright (c) 2000-2015 the FFmpeg developers
  built with gcc 4.9.3 (crosstool-NG 1.20.0) 20150311 (prerelease)
  configuration: --prefix=/usr --incdir='${prefix}/include/ffmpeg' --arch=i686 --target-os=linux --cross-prefix=/usr/local/x86_64-pc-linux-gnu/bin/x86_64-pc-linux-gnu- --enable-cross-compile --enable-optimizations --enable-pic --enable-gpl --enable-shared --disable-static --enable-version3 --enable-nonfree --enable-libfaac --enable-encoders --enable-pthreads --disable-bzlib --disable-protocol=rtp --disable-muxer=image2 --disable-muxer=image2pipe --disable-swscale-alpha --disable-ffserver --disable-ffplay --disable-doc --disable-devices --disable-bzlib --disable-altivec --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libmp3lame --disable-vaapi --disable-decoder=amrnb --disable-decoder=ac3 --disable-decoder=ac3_fixed --disable-encoder=zmbv --disable-encoder=dca --disable-encoder=ac3 --disable-encoder=ac3_fixed --disable-encoder=eac3 --disable-decoder=dca --disable-decoder=eac3 --disable-decoder=truehd --disable-decoder=hevc --disable-muxer=hevc --disable-demuxer=hevc --disable-parser=hevc --cc=/usr/local/x86_64-pc-linux-gnu/bin/x86_64-pc-linux-gnu-ccache-gcc --enable-yasm --enable-libx264 --enable-encoder=libx264
  libavutil      54. 27.100 / 54. 27.100
  libavcodec     56. 41.100 / 56. 41.100
  libavformat    56. 36.100 / 56. 36.100
  libavdevice    56.  4.100 / 56.  4.100
  libavfilter     5. 16.101 /  5. 16.101
  libswscale      3.  1.101 /  3.  1.101
  libswresample   1.  2.100 /  1.  2.100
  libpostproc    53.  3.100 / 53.  3.100
Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'input.mp4':
  Metadata:
    major_brand     : isom
    minor_version   : 512
    compatible_brands: isomiso2avc1mp41
    encoder         : Lavf56.36.100
  Duration: 00:00:36.12, start: 0.000000, bitrate: 2529 kb/s
    Stream #0:0(und): Video: h264 (Main) (avc1 / 0x31637661), yuv420p(tv, smpte170m/bt709/bt709), 406x720 [SAR 405:406 DAR 9:16], 2394 kb/s, 30 fps, 30 tbr, 12k tbn, 60 tbc (default)
    Metadata:
      handler_name    : VideoHandler
    Stream #0:1(und): Audio: aac (LC) (mp4a / 0x6134706D), 48000 Hz, stereo, fltp, 128 kb/s (default)
    Metadata:
      handler_name    : SoundHandler
File 'output.mp4' already exists. Overwrite ? [y/N] y
[libx264 @ 0x1cdc4a0] using SAR=81/256
[libx264 @ 0x1cdc4a0] using cpu capabilities: MMX2 SSE2Fast SSSE3 SSE4.2
[libx264 @ 0x1cdc4a0] profile High, level 4.0
[libx264 @ 0x1cdc4a0] 264 - core 148 - H.264/MPEG-4 AVC codec - Copyleft 2003-2016 - http://www.videolan.org/x264.html - options: cabac=1 ref=3 deblock=1:0:0 analyse=0x3:0x113 me=hex subme=7 psy=1 psy_rd=1.00:0.00 mixed_ref=1 me_range=16 chroma_me=1 trellis=1 8x8dct=1 cqm=0 deadzone=21,11 fast_pskip=1 chroma_qp_offset=-2 threads=3 lookahead_threads=1 sliced_threads=0 nr=0 decimate=1 interlaced=0 bluray_compat=0 constrained_intra=0 bframes=3 b_pyramid=2 b_adapt=1 b_bias=0 direct=1 weightb=1 open_gop=0 weightp=2 keyint=250 keyint_min=25 scenecut=40 intra_refresh=0 rc_lookahead=40 rc=crf mbtree=1 crf=23.0 qcomp=0.60 qpmin=0 qpmax=69 qpstep=4 ip_ratio=1.40 aq=1:1.00
Output #0, mp4, to 'output.mp4':
  Metadata:
    major_brand     : isom
    minor_version   : 512
    compatible_brands: isomiso2avc1mp41
    encoder         : Lavf56.36.100
    Stream #0:0: Video: h264 (libx264), yuv420p, 1920x1080 [SAR 81:256 DAR 9:16], q=-1--1, 30 fps, 30 tbn, 30 tbc (default)
    Metadata:
      encoder         : Lavc56.41.100 libx264
    Stream #0:1(und): Audio: aac, 0 channels, 128 kb/s (default)
    Metadata:
      handler_name    : SoundHandler
      encoder         : Lavc56.41.100 libfaac
Stream mapping:
  Stream #0:0 (h264) -> scale (graph 0)
  Stream #0:0 (h264) -> scale (graph 0)
  crop (graph 0) -> Stream #0:0 (libx264)
  Stream #0:1 -> #0:1 (aac (native) -> aac (libfaac))
Error while opening encoder for output stream #0:1 - maybe incorrect parameters such as bit_rate, rate, width or height


  


• Pipe video frames from ffmpeg to numpy array without loading whole movie into memory

  2 mai 2021, par marcman

  I'm not sure whether what I'm asking is feasible or functional, but I'm experimenting with trying to load frames from a video in an ordered, but "on-demand," fashion.

  


  Basically what I have now is to read the entire uncompressed video into a buffer by piping through stdout, e.g. :

  


  H, W = 1080, 1920 # video dimensions
video = '/path/to/video.mp4' # path to video

# ffmpeg command
command = [ "ffmpeg",
            '-i', video,
            '-pix_fmt', 'rgb24',
            '-f', 'rawvideo',
            'pipe:1' ]

# run ffmpeg and load all frames into numpy array (num_frames, H, W, 3)
pipe = subprocess.run(command, stdout=subprocess.PIPE, bufsize=10**8)
video = np.frombuffer(pipe.stdout, dtype=np.uint8).reshape(-1, H, W, 3)

# or alternatively load individual frames in a loop
nb_img = H*W*3 # H * W * 3 channels * 1-byte/channel
for i in range(0, len(pipe.stdout), nb_img):
    img = np.frombuffer(pipe.stdout, dtype=np.uint8, count=nb_img, offset=i).reshape(H, W, 3)


  


  I'm wondering if it's possible to do this same process, in Python, but without first loading the entire video into memory. In my mind, I'm picturing something like :

  


  

  1. open the a buffer

  


  2. seeking to memory locations on demand

  


  3. loading frames to numpy arrays

  


  


  I know there are other libraries, like OpenCV for example, that enable this same sort of behavior, but I'm wondering :

  


  

  • Is it possible to do this operation efficiently using this sort of ffmpeg-pipe-to-numpy-array operation ?

  


  • Does this defeat the speed-up benefit of ffmpeg directly rather than seeking/loading through OpenCV or first extracting frames and then loading individual files ?

  


  


• Encoding images into a movie file

  5 avril 2014, par RuAware

  I am trying to save jpgs into a movie, I have tried jcodec and alothough my s3 plays it fine other devices do not. including vlc and windows media

  I have just spent most of the day playing with MediaCodec, although the SDK is so high, it will help people with jelly bean and above. But I can not work out how to get the Files to the encoder and then write the file.

  Ideally I wont to support down to SDK 9/8

  Has anyone got any code they can share, either to get MediaCodec to work or another option. If you say ffmpeg, I'd love to but my jin knowledge is non existent and I will need a very good guide.

  Code for MediaCodec so far

  public class EncodeAndMux extends AsyncTask {
  
      private static int bitRate = 2000000;
  
      private static int MAX_INPUT = 100000;
  
      private static String mimeType = "video/avc";
  
  
  
      private int frameRate = 15;     
  
      private int colorFormat;
  
      private int stride = 1;
  
      private int sliceHeight = 2;        
  
  
  
      private MediaCodec encoder = null;
  
      private MediaFormat inputFormat;
  
      private MediaCodecInfo codecInfo = null;
  
      private MediaMuxer muxer;
  
      private boolean mMuxerStarted = false;
  
      private int mTrackIndex = 0;  
  
      private long presentationTime = 0;
  
      private Paint bmpPaint;
  
  
  
      private static int WAITTIME = 10000;
  
      private static String TAG = "ENCODE";
  
  
  
      private ArrayList<string> mFilePaths;
  
      private String mPath;
  
  
  
      private EncodeListener mListener;
  
      private int width = 320;
  
      private int height = 240;
  
      private double mSpeed = 1;
  
  
  
      public EncodeAndMux(ArrayList<string> filePaths, String savePath) {
  
          mFilePaths = filePaths;
  
          mPath = savePath;   
  
  
  
          // Create paint to draw BMP
  
          bmpPaint = new Paint();
  
          bmpPaint.setAntiAlias(true);
  
          bmpPaint.setFilterBitmap(true);
  
          bmpPaint.setDither(true);
  
      }
  
  
  
      public void setListner(EncodeListener listener) {
  
          mListener = listener;
  
      }
  
  
  
      // set the speed, how many frames a second
  
      public void setSpead(int speed) {
  
          mSpeed = speed;
  
      }
  
  
  
      public double getSpeed() {
  
          return mSpeed;
  
      }
  
  
  
      private long computePresentationTime(int frameIndex) {
  
          final long ONE_SECOND = 1000000;
  
          return (long) (frameIndex * (ONE_SECOND / mSpeed));
  
      }
  
  
  
      public interface EncodeListener {
  
          public void finished();
  
          public void errored();
  
      }
  
  
  
      @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
  
      @Override
  
      protected Boolean doInBackground(Integer... params) {
  
  
  
          try {
  
              muxer = new MediaMuxer(mPath, OutputFormat.MUXER_OUTPUT_MPEG_4);
  
          } catch (Exception e){ 
  
              e.printStackTrace();
  
          }
  
  
  
          // Find a code that supports the mime type
  
          int numCodecs = MediaCodecList.getCodecCount();
  
          for (int i = 0; i &lt; numCodecs &amp;&amp; codecInfo == null; i++) {
  
              MediaCodecInfo info = MediaCodecList.getCodecInfoAt(i);
  
              if (!info.isEncoder()) {
  
                  continue;
  
              }
  
              String[] types = info.getSupportedTypes();
  
              boolean found = false;
  
  
  
              for (int j = 0; j &lt; types.length &amp;&amp; !found; j++) {
  
                  if (types[j].equals(mimeType))
  
                      found = true;
  
              }
  
  
  
              if (!found)
  
                  continue;
  
              codecInfo = info;
  
          }
  
  
  
  
  
           for (int i = 0; i &lt; MediaCodecList.getCodecCount(); i++) {
  
                   MediaCodecInfo info = MediaCodecList.getCodecInfoAt(i);
  
                   if (!info.isEncoder()) {
  
                       continue;
  
                   }
  
  
  
                   String[] types = info.getSupportedTypes();
  
                   for (int j = 0; j &lt; types.length; ++j) {
  
                       if (types[j] != mimeType) 
  
                           continue;
  
                       MediaCodecInfo.CodecCapabilities caps = info.getCapabilitiesForType(types[j]);
  
                       for (int k = 0; k &lt; caps.profileLevels.length; k++) {
  
                           if (caps.profileLevels[k].profile == MediaCodecInfo.CodecProfileLevel.AVCProfileHigh &amp;&amp; caps.profileLevels[k].level == MediaCodecInfo.CodecProfileLevel.AVCLevel4) {
  
                               codecInfo = info;
  
                           }
  
                       }
  
                   }
  
           }
  
  
  
          Log.d(TAG, "Found " + codecInfo.getName() + " supporting " + mimeType);
  
  
  
          MediaCodecInfo.CodecCapabilities capabilities = codecInfo.getCapabilitiesForType(mimeType);
  
          for (int i = 0; i &lt; capabilities.colorFormats.length &amp;&amp; colorFormat == 0; i++) {
  
              int format = capabilities.colorFormats[i];
  
              switch (format) {
  
                  case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar:
  
                  case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedPlanar:
  
                  case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar:
  
                  case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedSemiPlanar:
  
                  case MediaCodecInfo.CodecCapabilities.COLOR_TI_FormatYUV420PackedSemiPlanar:
  
                  colorFormat = format;
  
                  break;
  
              }
  
          }
  
          Log.d(TAG, "Using color format " + colorFormat);
  
  
  
          // Determine width, height and slice sizes
  
          if (codecInfo.getName().equals("OMX.TI.DUCATI1.VIDEO.H264E")) {
  
              // This codec doesn&#39;t support a width not a multiple of 16,
  
              // so round down.
  
              width &amp;= ~15;
  
          }
  
  
  
          stride = width;
  
          sliceHeight = height;
  
  
  
          if (codecInfo.getName().startsWith("OMX.Nvidia.")) {
  
              stride = (stride + 15) / 16 * 16;
  
              sliceHeight = (sliceHeight + 15) / 16 * 16;
  
          }
  
  
  
          inputFormat = MediaFormat.createVideoFormat(mimeType, width, height);
  
          inputFormat.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
  
          inputFormat.setInteger(MediaFormat.KEY_FRAME_RATE, frameRate);
  
          inputFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, colorFormat);
  
          inputFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 5);
  
  //          inputFormat.setInteger("stride", stride);
  
  //          inputFormat.setInteger("slice-height", sliceHeight);
  
          inputFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, MAX_INPUT);
  
  
  
          encoder = MediaCodec.createByCodecName(codecInfo.getName());
  
          encoder.configure(inputFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
  
          encoder.start();
  
  
  
          ByteBuffer[] inputBuffers = encoder.getInputBuffers();
  
          ByteBuffer[] outputBuffers = encoder.getOutputBuffers();
  
  
  
          int inputBufferIndex= -1, outputBufferIndex= -1;
  
          BufferInfo info = new BufferInfo();
  
          for (int i = 0; i &lt; mFilePaths.size(); i++) {
  
  
  
              // use decode sample to calculate inSample size and then resize
  
              Bitmap bitmapIn = Images.decodeSampledBitmapFromPath(mFilePaths.get(i), width, height);   
  
  
  
              // Create blank bitmap 
  
              Bitmap bitmap = Bitmap.createBitmap(width, height, Config.ARGB_8888);                   
  
  
  
              // Center scaled image
  
              Canvas canvas = new Canvas(bitmap);                 
  
              canvas.drawBitmap(bitmapIn,(bitmap.getWidth()/2)-(bitmapIn.getWidth()/2),(bitmap.getHeight()/2)-(bitmapIn.getHeight()/2), bmpPaint);
  
  
  
              Log.d(TAG, "Bitmap width: " + bitmapIn.getWidth() + " height: " + bitmapIn.getHeight() + " WIDTH: " + width + " HEIGHT: " + height);
  
              byte[] dat = getNV12(width, height, bitmap);
  
              bitmap.recycle();
  
  
  
              // Exception occurred on this below line in Emulator, LINE No. 182//**
  
              inputBufferIndex = encoder.dequeueInputBuffer(WAITTIME);
  
              Log.i("DAT", "Size= "+dat.length);
  
  
  
              if(inputBufferIndex >= 0){
  
                  int samplesiz= dat.length;
  
                  inputBuffers[inputBufferIndex].put(dat);
  
                  presentationTime = computePresentationTime(i);
  
                  if (i == mFilePaths.size()) {
  
                      encoder.queueInputBuffer(inputBufferIndex, 0, samplesiz, presentationTime, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
  
                      Log.i(TAG, "Last Frame");
  
                  } else { 
  
                      encoder.queueInputBuffer(inputBufferIndex, 0, samplesiz, presentationTime, 0);
  
                  }
  
  
  
                  while(true) {
  
                     outputBufferIndex = encoder.dequeueOutputBuffer(info, WAITTIME);
  
                     Log.i("BATA", "outputBufferIndex="+outputBufferIndex);
  
                     if (outputBufferIndex >= 0) {
  
                         ByteBuffer encodedData = outputBuffers[outputBufferIndex];
  
                         if (encodedData == null) {
  
                             throw new RuntimeException("encoderOutputBuffer " + outputBufferIndex +
  
                                     " was null");
  
                         }
  
  
  
                         if ((info.flags &amp; MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
  
                             // The codec config data was pulled out and fed to the muxer when we got
  
                             // the INFO_OUTPUT_FORMAT_CHANGED status.  Ignore it.
  
                             Log.d(TAG, "ignoring BUFFER_FLAG_CODEC_CONFIG");
  
                             info.size = 0;
  
                         }
  
  
  
                         if (info.size != 0) {
  
                             if (!mMuxerStarted) {
  
                                 throw new RuntimeException("muxer hasn&#39;t started");
  
                             }
  
  
  
                             // adjust the ByteBuffer values to match BufferInfo (not needed?)
  
                             encodedData.position(info.offset);
  
                             encodedData.limit(info.offset + info.size);
  
  
  
                             muxer.writeSampleData(mTrackIndex, encodedData, info);
  
                             Log.d(TAG, "sent " + info.size + " bytes to muxer");
  
                         }
  
  
  
                         encoder.releaseOutputBuffer(outputBufferIndex, false);
  
  
  
                         inputBuffers[inputBufferIndex].clear();
  
                         outputBuffers[outputBufferIndex].clear();
  
  
  
                         if ((info.flags &amp; MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
  
                             break;      // out of while
  
                         }
  
  
  
                     } else if (outputBufferIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
  
                         // Subsequent data will conform to new format.
  
                         MediaFormat opmediaformat = encoder.getOutputFormat();
  
                         if (!mMuxerStarted) {
  
                             mTrackIndex = muxer.addTrack(opmediaformat);
  
                             muxer.start();
  
                             mMuxerStarted = true;
  
                         }
  
                         Log.i(TAG, "op_buf_format_changed: " + opmediaformat);
  
                     } else if(outputBufferIndex == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
  
                         outputBuffers = encoder.getOutputBuffers();
  
                         Log.d(TAG, "Output Buffer changed " + outputBuffers);
  
                     } else if(outputBufferIndex == MediaCodec.INFO_TRY_AGAIN_LATER) {
  
                         // No Data, break out
  
                         break;
  
                     } else {
  
                         // Unexpected State, ignore it
  
                         Log.d(TAG, "Unexpected State " + outputBufferIndex);
  
                     }
  
                  }
  
  
  
              }     
  
          }
  
  
  
          if (encoder != null) {
  
              encoder.flush();
  
              encoder.stop();
  
              encoder.release();
  
              encoder = null;
  
          }
  
  
  
          if (muxer != null) {
  
              muxer.stop();
  
              muxer.release();
  
              muxer = null;
  
          }
  
  
  
          return true;
  
  
  
      };
  
  
  
      @Override
  
      protected void onPostExecute(Boolean result) {
  
          if (result) {
  
              if (mListener != null)
  
                  mListener.finished();
  
          } else {
  
              if (mListener != null)
  
                  mListener.errored();
  
          }
  
          super.onPostExecute(result);
  
      }
  
  
  
  
  
  
  
      byte [] getNV12(int inputWidth, int inputHeight, Bitmap scaled) {
  
          int [] argb = new int[inputWidth * inputHeight];
  
          scaled.getPixels(argb, 0, inputWidth, 0, 0, inputWidth, inputHeight);
  
          byte [] yuv = new byte[inputWidth*inputHeight*3/2];
  
          encodeYUV420SP(yuv, argb, inputWidth, inputHeight);
  
          scaled.recycle();
  
          return yuv;
  
      }
  
  
  
  
  
      void encodeYUV420SP(byte[] yuv420sp, int[] argb, int width, int height) {
  
          final int frameSize = width * height;
  
          int yIndex = 0;
  
          int uvIndex = frameSize;
  
          int a, R, G, B, Y, U, V;
  
          int index = 0;
  
          for (int j = 0; j &lt; height; j++) {
  
              for (int i = 0; i &lt; width; i++) {
  
  
  
                  a = (argb[index] &amp; 0xff000000) >> 24; // a is not used obviously
  
                  R = (argb[index] &amp; 0xff0000) >> 16;
  
                  G = (argb[index] &amp; 0xff00) >> 8;
  
                  B = (argb[index] &amp; 0xff) >> 0;
  
  
  
                  // well known RGB to YVU algorithm
  
                  Y = ( (  66 * R + 129 * G +  25 * B + 128) >> 8) +  16;
  
                  V = ( ( -38 * R -  74 * G + 112 * B + 128) >> 8) + 128;
  
                  U = ( ( 112 * R -  94 * G -  18 * B + 128) >> 8) + 128;
  
  
  
                  yuv420sp[yIndex++] = (byte) ((Y &lt; 0) ? 0 : ((Y > 255) ? 255 : Y));
  
                  if (j % 2 == 0 &amp;&amp; index % 2 == 0) { 
  
                      yuv420sp[uvIndex++] = (byte)((V&lt;0) ? 0 : ((V > 255) ? 255 : V));
  
                      yuv420sp[uvIndex++] = (byte)((U&lt;0) ? 0 : ((U > 255) ? 255 : U));
  
                  }
  
  
  
                  index ++;
  
              }
  
          }
  
      }
  
  }
  
  </string></string>

  This has now been tested on 4 of my devices and works fine, is there are way to

  1/ Calculate the MAX_INPUT (to high and on the N7 II it crashes, I Don't want that happening once released)
  2/ Offer an api 16 solution ?
  3/ Do I need stride and stride height ?

  Thanks