Recherche avancée

Sur d’autres sites (6301)

• Trying to get thumbnail from a video by using ffmpeg

  27 mars 2014, par Khaled Hasania

  I'm trying to get thumbnail from a video , i did test this code on a side project non Yii project and it's working fine here is my action code.

          $ffmpeg = "C:\\ffmpeg\\bin\\ffmpeg";
  
          $videoFile = $_FILES['Project']['tmp_name']['file'];
  
          $imageFile = Yii::app()->basePath ."/../1.jpg";
  
          $size = "200x200";
  
          $getFromSecond = 5;
  
  
  
          $cmd = "$ffmpeg -i $videoFile -an -ss $getFromSecond -s $size $imageFile";
  
          shell_exec($cmd);

  This action called throw ajax by using dropzone Yii extension.

     $imageFile = "E:\xampp\htdocs\tme\protected\..\1.jpg"

• 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

• OpenCV and Cloud Cameras

  8 mai 2014, par Alexander

  So as a bit of context ; this program was built originally to work with USB cameras - but a few things changed. I’m trying to convert it to work with networked cameras, but my presence here should make it quite apparent what my level of success has been. I still consider myself somewhat new at programming, and definately new at visual processing/OpenCV - so please forgive a few blunders if I make them. I’m going to try to provide as much detail as possible, so apologies for the length below.

  ---

  I’m using :

  • OpenCV 2.4.6.0
  • Microsoft Visual Studio Express 2012
  • C++
  • D-Link Cloud Camera 7100

  ---

  I am trying to access the DLink camera’s video feed through OpenCV.

  I can access the camera through it’s IP address with a browser without any issues. Unfourtunately ; my program is less cooperative. I’ve put it on two computers (excluding the computer it gets compiled on, which for unrelated/unchangable reasons cannot be placed on the same network the network camera is on) which both fail to grant my program access to the camera. One computer gives the OpenCV-generated error :

  warning : Error opening file (../../modules/highgui/src/cap_ffmpeg_impl.hpp:529)

  This error occurs with just about everything I try that doesn’t somehow generate more problems. The other computer (same code) generates no such error - it just doesn’t get the camera’s output either.

  For reference - the code in OpenCV’s cap_ffmpeg_impl.hpp around line 529 is as follows :

  522    bool CvCapture_FFMPEG::open( const char* _filename )
  
  523    {
  
  524        unsigned i;
  
  525        bool valid = false;
  
  526
  
  527        close();
  
  528
  
  529    #if LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(52, 111, 0)
  
  530        int err = avformat_open_input(&ic, _filename, NULL, NULL);
  
  531    #else
  
  532        int err = av_open_input_file(&ic, _filename, NULL, 0, NULL);
  
  533    #endif
  
  ...
  
  616    }

  ...for which I have no idea what I’m looking at.

  My entire program is rather large, so I’m editing it down as much as possible to help keep this readable - if I miss something you think is important please leave a comment telling me as much so I can throw it in...

  First up - this is one of the first things in main() so I don’t have to recompile every time I want to try a different value :

  3380    cout << "Please Enter Video Location: ";
  
  3381    cin >> videoFeedAddress;
  
  3382    cout << "videoFeedAddress: " << videoFeedAddress << endl;

  Just a simple string value.
  Next up - the actual place we’re having the problem ! Probably...

  Note that in the below code - if networkCam is false and a USB camera is connected there is no problem. The error here is caused by line 153.

  121    void displayCameraView()
  
  122    {
  
  123     if(camviewOn) // displayCameraView is triggered by a button the user can press as often as they want. Doesn't mean we want to let them break everything.
  
  124     {return;}
  
  125     else
  
  126     {
  
  127         CvCapture* cv_cap;
  
  128         VideoCapture cv_cap_IP;
  
  129         Mat color_img_IP;
  
  130         camviewOn = true;
  
  131         int capture;
  
  132         IplImage* color_img;
  
  133         if(!networkCam)
  
  134         {
  
  135             cv_cap = cvCaptureFromCAM(0);
  
  136             Sleep(100);
  
  137             if(!cv_cap)
  
  138             {
  
  139                 setExitError(1002);
  
  140                 if(textOutput){cout << "Video Error: Video input will not work.\n";}
  
  141                 MessageBox(hwnd, "Error opening camera.", "Error", MB_ICONEXCLAMATION);
  
  142                 cvReleaseCapture( &cv_cap );
  
  143                 cvDestroyWindow("Camera View");
  
  144                 return;
  
  145             }
  
  146             color_img = cvQueryFrame(cv_cap);
  
  147             clickPointStorage.create(((Mat)color_img).rows, ((Mat)color_img).cols, CV_8UC3);
  
  148         }
  
  149         else
  
  150         {
  
  151             ///*\
  
  152             
  
  153             cv_cap_IP.open(videoFeedAddress);
  
  154             Sleep(100);
  
  155             if(!cv_cap_IP.isOpened())
  
  156             {
  
  157                 setExitError(1002);
  
  158                 if(textOutput){cout << "Video Error: Video input will not work.\n";}
  
  159                 MessageBox(hwnd, "Error opening camera.", "Error", MB_ICONEXCLAMATION);
  
  160                 cvDestroyWindow("Camera View");
  
  161                 return;
  
  162             }
  
  163             clickPointStorage.create(color_img_IP.rows, color_img_IP.cols, CV_8UC3);
  
  164    
  
  165             //\*/
  
  166         }
  
  167         clickPointStorage.setTo(Scalar(0, 0, 0));
  
  168         cvNamedWindow("Camera View", 0); // create window
  
  169         cvSetMouseCallback("Camera View", CallBackFunc, NULL);
  
  170         IplImage* IplClickPointStorage = new IplImage(clickPointStorage);
  
  171         IplImage* Ipl_IP_Img;
  
  172         
  
  173         if(!networkCam)
  
  174         {
  
  175             for(;;)
  
  176             {
  
  177                 IplClickPointStorage = new IplImage(clickPointStorage);
  
  178                 cvAdd(cvQueryFrame(cv_cap), IplClickPointStorage, color_img); // get frame
  
  181                 cvShowImage("Camera View", color_img); // show frame
  
  182                 capture = cvWaitKey(10); // wait 10 ms or for key stroke
  
  183                 if(capture == 27 || capture == 13 || capture == 32){break;} // if ESC, Return, or space; close window.
  
  184             }
  
  185             /* clean up */
  
  186             cvReleaseCapture( &cv_cap );
  
  187             delete cv_cap;
  
  188             delete IplClickPointStorage;
  
  189         }
  
  190         else
  
  191         {
  
  192             ///*\
  
  193    
  
  194             for(;;)
  
  195             {
  
  196                 cv_cap_IP.read(color_img_IP);
  
  197                 IplClickPointStorage = new IplImage(clickPointStorage);
  
  198                 Ipl_IP_Img = new IplImage(color_img_IP);
  
  199                 cvAdd(Ipl_IP_Img, IplClickPointStorage, color_img);
  
  200                 cvShowImage("Camera View", color_img); // show frame
  
  201                 capture = cvWaitKey(10); // wait 10 ms or for key stroke
  
  202                 if(capture == 27 || capture == 13 || capture == 32){break;} // if ESC, Return, or space; close window.
  
  203             }
  
  204             cv_cap_IP.release();
  
  205             delete Ipl_IP_Img;
  
  206             delete IplClickPointStorage;
  
  207    
  
  208             //\*/
  
  209         }
  
  210         cvDestroyWindow("Camera View");
  
  211         camviewOn = false;
  
  212     }
  
  213     return;
  
  214    }

  As I said, on one computer I get the above error - both of them give me my own error from here :

  155             if(!cv_cap_IP.isOpened())
  
  156             {
  
  157                 setExitError(1002);
  
  158                 if(textOutput){cout << "Video Error: Video input will not work.\n";}
  
  159                 MessageBox(hwnd, "Error opening camera.", "Error", MB_ICONEXCLAMATION);
  
  160                 cvDestroyWindow("Camera View");
  
  161                 return;
  
  162             }

  ...which of course tells me cv_cap_IP is not open. One of my primary concerns is with the videoFeedAddress variable. No value I enter seems to get a different result.

  I searched the Googles - and come across a number of different "possible" answers - but none of them seem to work for me. If you attempt to google it yourself you may come across some of these :

  1. This is one of the first configurations my code was in. No dice.
  2. This one is talking about files - not cameras. It also mentions codecs - but I wouldn’t be able to watch it in a web browser if that were the problem, right ? (Correct me if I’m wrong here...)
  3. This one has the wrong error code/points to the wrong line of code !
  4. This one mentions compiling OpenCV with ffmpeg support - but I believe 2.4.6.0 already comes with that all set and ready ! Otherwise it’s not that different from what I’ve already tried.
  5. Now THIS one appears to be very similar to what I have, but the only proposed solution doesn’t really help as I had already located a list of connections. I do not believe this is a duplicate, because as per THIS meta discussion I had a lot more information and so didn’t feel comfortable taking over someone else’s question - especially if I end up needing to add even more information later.

  Back to the videoFeedAddress variable : I found THIS site that lists a number of possible addresses to connect to it. since there exists no 7100 anywhere in the list - and the install is the same for the DCS-7010L I used the addresses found next to the DCS-7010L listings. Most of them can be reached through the browser, confirming that they reach the camera - but they don’t seem to affect the outcome when I change them.

  As per many of the above links, I’ve tried many of them both with any without username:password, port number (554), and variations on ?.mjpg (the format) at the end.

  Any ideas ?