Recherche avancée

Sur d’autres sites (9217)

• Android bytedeco javacpp ffmpeg decode h264 bytes to yuv and render with openGL ES 2.0. Wrong colors

  9 juin 2015, par tema_man

  there ! I try to display a video stream, which comes from server as byte array.
  Data in this array is h264 encoded image and i decode it with bytedeco javacpp-presets library in this way :

  public class DMDecoder {
  
  
  
  private static final String LOG_TAG = "DMDecoder";
  
  
  
  private AVCodec avCodec;
  
  private AVCodecContext avCodecContext;
  
  private AVFrame avFrame;
  
  private AVPacket avPacket;
  
  private boolean wasIFrame;
  
  private long IFrameTimeStampMs;
  
  private int maxFps;
  
  private int codecId;
  
  
  
  private DMDecoderCallback callback;
  
  
  
  public DMDecoder(DMDecoderCallback cb) {
  
      this.callback = cb;
  
      this.codecId = AV_CODEC_ID_H264;
  
      avcodec_register_all();
  
      restart();
  
  }
  
  
  
  public void restart() {
  
      stop();
  
      start();
  
  }
  
  
  
  public void stop() {
  
      frames = 0;
  
      if (avCodecContext != null) {
  
          avcodec_close(avCodecContext);
  
          avcodec_free_context(avCodecContext);
  
          avCodecContext = null;
  
      }
  
  
  
      if (avCodec != null) {
  
          av_free(avCodec);
  
          avCodec = null;
  
      }
  
  
  
      if (avFrame != null) {
  
          av_frame_free(avFrame);
  
          avFrame = null;
  
      }
  
  
  
      if (avPacket != null) {
  
          av_free_packet(avPacket);
  
          avPacket = null;
  
      }
  
  }
  
  
  
  public void start() {
  
      avCodec = avcodec_find_decoder(codecId);
  
  
  
      avCodecContext = avcodec_alloc_context3(avCodec);
  
      AVDictionary opts = new AVDictionary();
  
      avcodec_open2(avCodecContext, avCodec, opts);
  
  
  
      avFrame = av_frame_alloc();
  
      avPacket = new AVPacket();
  
      av_init_packet(avPacket);
  
  }
  
  
  
  public VideoFrame decode(byte[] data, int dataOffset, int dataSize) {
  
      avPacket.pts(AV_NOPTS_VALUE);
  
      avPacket.dts(AV_NOPTS_VALUE);
  
      avPacket.data(new BytePointer(data).position(dataOffset));
  
      avPacket.size(dataSize);
  
      avPacket.pos(-1);
  
  
  
      IntBuffer gotPicture = IntBuffer.allocate(1);
  
  
  
      int processedBytes = avcodec_decode_video2(
  
              avCodecContext, avFrame, gotPicture, avPacket);
  
  
  
      if (avFrame.width() == 0 || avFrame.height() == 0) return null;
  
  
  
      VideoFrame frame = new VideoFrame();
  
  
  
     frame.colorPlane0 = new byte[avFrame.width() * avFrame.height()];
  
     frame.colorPlane1 = new byte[avFrame.width() / 2 * avFrame.height() / 2];
  
     frame.colorPlane2 = new byte[avFrame.width() / 2 * avFrame.height() / 2];
  
  
  
      if (avFrame.data(0) != null) avFrame.data(0).get(frame.colorPlane0);
  
      if (avFrame.data(1) != null) avFrame.data(1).get(frame.colorPlane1);
  
      if (avFrame.data(2) != null) avFrame.data(2).get(frame.colorPlane2);
  
  
  
      frame.lineSize0 = avFrame.width();
  
      frame.lineSize1 = avFrame.width() / 2;
  
      frame.lineSize2 = avFrame.width() / 2;
  
  
  
      frame.width = avFrame.width();
  
      frame.height = avFrame.height();
  
  
  
      return frame;
  
    }
  
  }

  VideoFrame class is just simple POJO :

  public class VideoFrame {
  
      public byte[] colorPlane0;
  
      public byte[] colorPlane1;
  
      public byte[] colorPlane2;
  
      public int lineSize0;
  
      public int lineSize1;
  
      public int lineSize2;
  
      public int width;
  
      public int height;
  
      public long presentationTime;
  
  }

  After decoding i send this frame to my GLRenderer class

  public class GLRenderer implements GLSurfaceView.Renderer {
  
  
  
      private static final String LOG_TAG = "GLRenderer";
  
  
  
      private TexturePlane plane;
  
  
  
      private ConcurrentLinkedQueue<videoframe> frames;
  
      private int maxFps = 30;
  
      private VideoFrame currentFrame;
  
      private long startTime, endTime;
  
      private int viewWidth, viewHeight;
  
      private boolean isFirstFrameProcessed;
  
  
  
      public GLRenderer(int viewWidth, int viewHeight) {
  
          frames = new ConcurrentLinkedQueue&lt;>();
  
          this.viewWidth = viewWidth;
  
          this.viewHeight = viewHeight;
  
      }
  
  
  
      // mMVPMatrix is an abbreviation for "Model View Projection Matrix"
  
      private final float[] mMVPMatrix = new float[16];
  
      private final float[] mProjectionMatrix = new float[16];
  
      private final float[] mViewMatrix = new float[16];
  
  
  
      @Override
  
  
  
      public void onSurfaceCreated(GL10 unused, EGLConfig config) {
  
          // Set the background frame color
  
          GLES20.glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
  
  
  
          plane = new TexturePlane();
  
      }
  
  
  
      public void setMaxFps(int maxFps) {
  
          this.maxFps = maxFps;
  
      }
  
  
  
      @Override
  
      public void onDrawFrame(GL10 unused) {
  
  
  
  
  
          // Draw background color
  
          GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
  
  
  
          // Set the camera position (View matrix)
  
          Matrix.setLookAtM(mViewMatrix, 0, 0, 0, -3, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
  
  
  
          // Calculate the projection and view transformation
  
          Matrix.multiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mViewMatrix, 0);
  
  
  
          if (!isFirstFrameProcessed) checkViewPort(viewWidth, viewHeight);
  
  
  
          if (maxFps > 0 &amp;&amp; startTime > 0) {
  
              endTime = System.currentTimeMillis();
  
              long time = endTime - startTime;
  
              //
  
              long wantedTime = 1000 / maxFps;
  
              //
  
              long wait;
  
              if (time &lt; wantedTime) {
  
                  wait = wantedTime - time;
  
                  //
  
                  try {
  
                      Thread.sleep(wait);
  
                  } catch (InterruptedException e) {
  
                      Log.e(LOG_TAG, "thread interrupted exception");
  
                  }
  
              }
  
          }
  
          startTime = System.currentTimeMillis();
  
          tick();
  
          plane.draw(mMVPMatrix);
  
      }
  
  
  
      private void updateFrame(VideoFrame frame) {
  
          plane.updateTexture(frame.colorPlane0, frame.width, frame.height, 0);
  
          plane.updateTexture(frame.colorPlane1, frame.width / 2, frame.height / 2, 1);
  
          plane.updateTexture(frame.colorPlane2, frame.width / 2, frame.height / 2, 2);
  
          plane.setTextureWidth(frame.width);
  
          plane.setTextureHeight(frame.height);
  
      }
  
  
  
      private void tick() {
  
  
  
          if (frames.isEmpty()) return;
  
  
  
          VideoFrame frame = frames.peek();
  
          if (frame == null) return;
  
  
  
          long tms = System.currentTimeMillis();
  
          if (frame.presentationTime &lt;= tms) {
  
              updateFrame(frame);
  
              currentFrame = frame;
  
              frames.remove(frame);
  
          }
  
      }
  
  
  
      @Override
  
      public void onSurfaceChanged(GL10 unused, int width, int height) {
  
          checkViewPort(width, height);
  
          viewWidth = width;
  
          viewHeight = height;
  
          plane.setTextureWidth(width);
  
          plane.setTextureHeight(height);
  
      }
  
  
  
      private void checkViewPort(int width, int height) {
  
          float viewRatio = (float) width / height;
  
          if (currentFrame != null) {
  
              float targetRatio = (float) currentFrame.width / currentFrame.height;
  
              int x, y, newWidth, newHeight;
  
              if (targetRatio > viewRatio) {
  
                  newWidth = width;
  
                  newHeight = (int) (width / targetRatio);
  
                  x = 0;
  
                  y = (height - newHeight) / 2;
  
              } else {
  
                  newHeight = height;
  
                  newWidth = (int) (height * targetRatio);
  
                  y = 0;
  
                  x = (width - newWidth) / 2;
  
              }
  
              GLES20.glViewport(x, y, newWidth, newHeight);
  
          } else {
  
              GLES20.glViewport(0, 0, width, height);
  
          }
  
  
  
          Matrix.frustumM(mProjectionMatrix, 0, 1, -1, -1, 1, 3, 4);
  
      }
  
  
  
      public void addFrame(VideoFrame frame) {
  
          if (frame != null) {
  
              frames.add(frame);
  
          }
  
      }
  
  }
  
  </videoframe>

  GLRenderer works with simple openGL polygon, on which i draw all textures

      public class TexturePlane {
  
  
  
      private static final String LOG_TAG = "TexturePlane";
  
  
  
      private final String vertexShaderCode = "" +
  
      "uniform mat4 uMVPMatrix;" +
  
      "attribute vec4 vPosition;" +
  
      "attribute vec2 a_TexCoordinate;" +
  
      "varying vec2 v_TexCoordinate;" +
  
  
  
      "void main() {" +
  
      "  gl_Position = uMVPMatrix * vPosition;" +
  
      "  v_TexCoordinate = a_TexCoordinate;" +
  
      "}";
  
  
  
      private final String fragmentShaderCode = "" +
  
      "precision mediump float;" +
  
      "varying vec2 v_TexCoordinate;" +
  
      "uniform sampler2D s_texture_y;" +
  
      "uniform sampler2D s_texture_u;" +
  
      "uniform sampler2D s_texture_v;" +
  
  
  
      "void main() {" +
  
      "   float y = texture2D(s_texture_y, v_TexCoordinate).r;" +
  
      "   float u = texture2D(s_texture_u, v_TexCoordinate).r - 0.5;" +
  
      "   float v = texture2D(s_texture_v, v_TexCoordinate).r - 0.5;" +
  
  
  
      "   float r = y + 1.13983 * v;" +
  
      "   float g = y - 0.39465 * u - 0.58060 * v;" +
  
      "   float b = y + 2.03211 * u;" +
  
  
  
      "   gl_FragColor = vec4(r, g, b, 1.0);" +
  
  
  
      "}";
  
  
  
      private final FloatBuffer vertexBuffer;
  
      private final FloatBuffer textureBuffer;
  
      private final ShortBuffer drawListBuffer;
  
      private final int mProgram;
  
      private int mPositionHandle;
  
      private int mMVPMatrixHandle;
  
  
  
          // number of coordinates per vertex in this array
  
      private static final int COORDS_PER_VERTEX = 3;
  
      private static final int COORDS_PER_TEXTURE = 2;
  
  
  
      private static float squareCoords[] = {
  
          -1f, 1f, 0.0f,
  
          -1f, -1f, 0.0f,
  
          1f, -1f, 0.0f,
  
          1f, 1f, 0.0f
  
      };
  
  
  
      private static float uvs[] = {
  
          0.0f, 0.0f,
  
          0.0f, 1.0f,
  
          1.0f, 1.0f,
  
          1.0f, 0.0f
  
      };
  
  
  
      private final short drawOrder[] = {0, 1, 2, 0, 2, 3}; // order to draw vertices
  
      private final int vertexStride = COORDS_PER_VERTEX * 4; // 4 bytes per vertex
  
  
  
      private int textureWidth = 640;
  
      private int textureHeight = 480;
  
  
  
      private int yTextureUniformHandle;
  
      private int uTextureUniformHandle;
  
      private int vTextureUniformHandle;
  
  
  
      private int yTextureHandle;
  
      private int uTextureHandle;
  
      private int vTextureHandle;
  
  
  
      private int mTextureCoordinateHandle;
  
  
  
      public void setTextureWidth(int textureWidth) {
  
          this.textureWidth = textureWidth;
  
      }
  
  
  
      public int getTextureWidth() {
  
          return textureWidth;
  
      }
  
  
  
      public void setTextureHeight(int textureHeight) {
  
          this.textureHeight = textureHeight;
  
      }
  
  
  
      public int getTextureHeight() {
  
          return textureHeight;
  
      }
  
  
  
      /**
  
       * Sets up the drawing object data for use in an OpenGL ES context.
  
       */
  
      public TexturePlane() {
  
              // initialize vertex byte buffer for shape coordinates
  
          ByteBuffer bb = ByteBuffer.allocateDirect(squareCoords.length * 4);
  
          bb.order(ByteOrder.nativeOrder());
  
          vertexBuffer = bb.asFloatBuffer();
  
          vertexBuffer.put(squareCoords);
  
          vertexBuffer.position(0);
  
  
  
              // initialize byte buffer for the draw list
  
          ByteBuffer dlb = ByteBuffer.allocateDirect(drawOrder.length * 2);
  
          dlb.order(ByteOrder.nativeOrder());
  
          drawListBuffer = dlb.asShortBuffer();
  
          drawListBuffer.put(drawOrder);
  
          drawListBuffer.position(0);
  
  
  
              // initialize byte buffer for the draw list
  
          ByteBuffer tbb = ByteBuffer.allocateDirect(uvs.length * 4);
  
          tbb.order(ByteOrder.nativeOrder());
  
          textureBuffer = tbb.asFloatBuffer();
  
          textureBuffer.put(uvs);
  
          textureBuffer.position(0);
  
  
  
              mProgram = GLES20.glCreateProgram();             // create empty OpenGL Program
  
              compileShaders();
  
              setupTextures();
  
          }
  
  
  
          public void setupTextures() {
  
              yTextureHandle = setupTexture(null, textureWidth, textureHeight, 0);
  
              uTextureHandle = setupTexture(null, textureWidth, textureHeight, 1);
  
              vTextureHandle = setupTexture(null, textureWidth, textureHeight, 2);
  
          }
  
  
  
          public int setupTexture(ByteBuffer data, int width, int height, int index) {
  
              final int[] textureHandle = new int[1];
  
  
  
              GLES20.glGenTextures(1, textureHandle, 0);
  
  
  
              if (textureHandle[0] != 0) {
  
                      // Bind to the texture in OpenGL
  
                  GLES20.glActiveTexture(GLES20.GL_TEXTURE0 + index);
  
                  GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureHandle[0]);
  
  
  
                  updateTexture(data, width, height, index);
  
  
  
                      // Set filtering
  
                  GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
  
                  GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
  
  
  
                      // Set wrapping mode
  
                  GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_REPEAT);
  
                  GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_REPEAT);
  
              }
  
  
  
              if (textureHandle[0] == 0) {
  
                  Log.e(LOG_TAG, "Error loading texture.");
  
              }
  
  
  
              return textureHandle[0];
  
          }
  
  
  
          public void updateTexture(byte[] data, int width, int height, int index) {
  
  
  
              if (data == null) {
  
                  if (width == 0 || height == 0) {
  
                      width = textureWidth;
  
                      height = textureHeight;
  
                  }
  
  
  
                  data = new byte[width * height];
  
                  if (index == 0) {
  
                      Arrays.fill(data, y);
  
                  } else if (index == 1) {
  
                      Arrays.fill(data, u);
  
                  } else {
  
                      Arrays.fill(data, v);
  
                  }
  
              } 
  
  
  
              byteBuffer.wrap(data);
  
              byteBuffer.position(0);
  
  
  
              GLES20.glActiveTexture(GLES20.GL_TEXTURE0 + index);
  
  
  
              GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_LUMINANCE,
  
                  width, height, 0, GLES20.GL_LUMINANCE, GLES20.GL_UNSIGNED_BYTE, byteBuffer);
  
          }
  
  
  
          private void compileShaders() {
  
              // prepare shaders and OpenGL program
  
              int vertexShader = loadShader(
  
                  GLES20.GL_VERTEX_SHADER,
  
                  vertexShaderCode);
  
              int fragmentShader = loadShader(
  
                  GLES20.GL_FRAGMENT_SHADER,
  
                  fragmentShaderCode);
  
  
  
              GLES20.glAttachShader(mProgram, vertexShader);   // add the vertex shader to program
  
              GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program
  
              GLES20.glLinkProgram(mProgram);                  // create OpenGL program executables
  
              checkGlError("glLinkProgram");
  
  
  
              // Add program to OpenGL environment
  
              GLES20.glUseProgram(mProgram);
  
  
  
              mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");
  
              mTextureCoordinateHandle = GLES20.glGetAttribLocation(mProgram, "a_TexCoordinate");
  
  
  
              GLES20.glEnableVertexAttribArray(mPositionHandle);
  
              GLES20.glEnableVertexAttribArray(mTextureCoordinateHandle);
  
  
  
              yTextureUniformHandle = GLES20.glGetUniformLocation(mProgram, "s_texture_y");
  
              uTextureUniformHandle = GLES20.glGetUniformLocation(mProgram, "s_Texture_u");
  
              vTextureUniformHandle = GLES20.glGetUniformLocation(mProgram, "s_Texture_v");
  
  
  
              mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
  
              checkGlError("glGetUniformLocation");
  
          }
  
  
  
      /**
  
       * Utility method for compiling a OpenGL shader.
  
       * <p></p>
  
       * <p><strong>Note:</strong> When developing shaders, use the checkGlError()
  
       * method to debug shader coding errors.</p>
  
       *
  
       * @param type       - Vertex or fragment shader type.
  
       * @param shaderCode - String containing the shader code.
  
       * @return - Returns an id for the shader.
  
       */
  
      public int loadShader(int type, String shaderCode) {
  
  
  
              // create a vertex shader type (GLES20.GL_VERTEX_SHADER)
  
              // or a fragment shader type (GLES20.GL_FRAGMENT_SHADER)
  
          int shader = GLES20.glCreateShader(type);
  
  
  
              // add the source code to the shader and compile it
  
          GLES20.glShaderSource(shader, shaderCode);
  
          GLES20.glCompileShader(shader);
  
  
  
          return shader;
  
      }
  
  
  
      /**
  
       * Utility method for debugging OpenGL calls. Provide the name of the call
  
       * just after making it:
  
       * <p></p>
  
       * <pre>
  
       * mColorHandle = GLES20.glGetUniformLocation(mProgram, "vColor");
  
       * MyGLRenderer.checkGlError("glGetUniformLocation");</pre>
  
       *
  
       * If the operation is not successful, the check throws an error.
  
       *
  
       * @param glOperation - Name of the OpenGL call to check.
  
       */
  
      public void checkGlError(String glOperation) {
  
          int error;
  
          String errorString;
  
          while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
  
              errorString = GLU.gluErrorString(error);
  
              String message = glOperation + ": glError " + error + ": " + errorString;
  
              Log.e(LOG_TAG, message);
  
              throw new RuntimeException(message);
  
          }
  
      }
  
  
  
      public void draw(float[] mvpMatrix) {
  
  
  
              // Prepare the triangle coordinate data
  
          GLES20.glVertexAttribPointer(
  
              mPositionHandle, COORDS_PER_VERTEX,
  
              GLES20.GL_FLOAT, false,
  
              vertexStride, vertexBuffer);
  
  
  
          GLES20.glVertexAttribPointer(
  
              mTextureCoordinateHandle, COORDS_PER_TEXTURE,
  
              GLES20.GL_FLOAT, false,
  
              0, textureBuffer);
  
  
  
          GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0);
  
          checkGlError("glUniformMatrix4fv");
  
  
  
          GLES20.glUniform1i(yTextureUniformHandle, 0);
  
          GLES20.glUniform1i(uTextureUniformHandle, 1);
  
          GLES20.glUniform1i(vTextureUniformHandle, 2);
  
  
  
              // Draw the square
  
          GLES20.glDrawElements(
  
              GLES20.GL_TRIANGLES, drawOrder.length,
  
              GLES20.GL_UNSIGNED_SHORT, drawListBuffer);
  
      }
  
  } 

  But i have a problem there. My GL surface display image with wrong colors. image

  What i’m doing wrong ?

  UPDATE :

  As Ronald S. Bultje say, i added glBindTexture(...) function in my code. And now updateTexture(...) method looks like this :

  public void updateTexture(byte[] data, int width, int height, int index) {
  
  
  
      if (data == null) {
  
          if (width == 0 || height == 0) {
  
              width = textureWidth;
  
              height = textureHeight;
  
          }
  
  
  
          data = new byte[width * height];
  
          if (index == 0) {
  
              Arrays.fill(data, y);
  
          } else if (index == 1) {
  
              Arrays.fill(data, u);
  
          } else {
  
              Arrays.fill(data, v);
  
          }
  
      } 
  
  
  
      byteBuffer.wrap(data);
  
      byteBuffer.position(0);
  
  
  
      GLES20.glActiveTexture(GLES20.GL_TEXTURE0 + index);
  
  
  
      int textureHandle = index == 0 ? yTextureHandle : index == 1 ? uTextureHandle : vTextureHandle;
  
      GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureHandle);
  
  
  
      GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_LUMINANCE,
  
          width, height, 0, GLES20.GL_LUMINANCE, GLES20.GL_UNSIGNED_BYTE, byteBuffer);
  
  }

• Revision 18c83b3714 : Compressed/uncompressed frame header changes. Adding API to read/write uncompre

  29 mai 2013, par Dmitry Kovalev

  Changed Paths :
   Modify /vp9/common/vp9_common.h

  
   Delete /vp9/common/vp9_header.h

  
   Modify /vp9/common/vp9_modecont.h

  
   Modify /vp9/common/vp9_onyxc_int.h

  
   Modify /vp9/decoder/vp9_decodframe.c

  
   Add /vp9/decoder/vp9_read_bit_buffer.h

  
   Modify /vp9/encoder/vp9_bitstream.c

  
   Modify /vp9/encoder/vp9_onyx_if.c

  
   Add /vp9/encoder/vp9_write_bit_buffer.h

  
   Modify /vp9/vp9_common.mk

  
   Modify /vp9/vp9_dx_iface.c

  
   Modify /vp9/vp9cx.mk

  
   Modify /vp9/vp9dx.mk

  
  
  Compressed/uncompressed frame header changes.

  Adding API to read/write uncompressed frame header bits (it is not final
  yet). Separate functions to read/write uncompressed header. Moving
  clr_type, error_resilient_mode, refresh_frame_context,
  frame_parallel_decoding_mode, frame_context_idx from compressed partition
  to uncompressed frame header.

  Change-Id : Id3ed8a387980c652ae147549412f4ec24a0a5bd0

• Encoding H.264 video using FFmpeg C API

  18 juillet 2014, par GummiB

  I’m trying to encode a H.264 video with the FFMPEG C API.
  I have successfully compiled and executed the decoding/encoding example provided by FFMPEG.

  The problem I’m facing is that the .mpg file (encoded with AV_CODEC_ID_MPEG1VIDEO) the example creates works. Windows creates a thumbnail and everything. On the other hand the .h264 (encoded with AV_CODEC_ID_H264) file does not. When I try to play the file in VLC the play/pause button just flickers, no thumbnail in windows, no nothing.

  During encoding libx264 reports the following :

  [libx264 @ 004b81a0] using cpu capabilities: MMX2 SSE2Fast SSSE3 SSE4.2 AVX
  
  [libx264 @ 004b81a0] profile High, level 1.3
  
  [libx264 @ 004b81a0] frame I:3     Avg QP:26.79  size:  2116
  
  [libx264 @ 004b81a0] frame P:12    Avg QP:26.60  size:   789
  
  [libx264 @ 004b81a0] frame B:10    Avg QP:31.39  size:   499
  
  [libx264 @ 004b81a0] consecutive B-frames: 20.0% 80.0%
  
  [libx264 @ 004b81a0] mb I  I16..4: 78.3% 11.6% 10.1%
  
  [libx264 @ 004b81a0] mb P  I16..4: 77.4%  0.6%  0.1%  P16..4: 20.3%  0.7%  0.9%  0.0%  0.0%    skip: 0.0%
  
  [libx264 @ 004b81a0] mb B  I16..4:  0.0%  0.0%  0.0%  B16..8:  9.4%  0.2%  0.0%  direct:11.0%  skip:79.4%  L0:25.4% L1:35.4% BI:39.2%
  
  [libx264 @ 004b81a0] final ratefactor: 17.03
  
  [libx264 @ 004b81a0] 8x8 transform intra:3.4% inter:31.3%
  
  [libx264 @ 004b81a0] direct mvs  spatial:0.0% temporal:100.0%
  
  [libx264 @ 004b81a0] coded y,uvDC,uvAC intra: 4.4% 35.8% 1.6% inter: 1.3% 34.5% 9.5%
  
  [libx264 @ 004b81a0] i16 v,h,dc,p:  0%  0%  0% 100%
  
  [libx264 @ 004b81a0] i8 v,h,dc,ddl,ddr,vr,hd,vl,hu:  7% 20% 17% 49%  0%  0%  0%  1%  6%
  
  [libx264 @ 004b81a0] i4 v,h,dc,ddl,ddr,vr,hd,vl,hu: 14%  7% 18% 45%  2%  7%  2%  3%  2%
  
  [libx264 @ 004b81a0] i8c dc,h,v,p:  2%  6%  4% 88%
  
  [libx264 @ 004b81a0] Weighted P-Frames: Y:0.0% UV:0.0%
  
  [libx264 @ 004b81a0] ref P L0: 95.6%  1.6%  2.2%  0.5%  0.2%
  
  [libx264 @ 004b81a0] ref B L0: 67.5% 28.5%  3.2%  0.8%
  
  [libx264 @ 004b81a0] kb/s:166.45

  "ffprobe.exe test.h264 -show_streams" returns

  [STREAM]
  
  index=0
  
  codec_name=h264
  
  codec_long_name=H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10
  
  profile=High
  
  codec_type=video
  
  codec_time_base=1/50
  
  codec_tag_string=[0][0][0][0]
  
  codec_tag=0x0000
  
  width=352
  
  height=288
  
  has_b_frames=1
  
  sample_aspect_ratio=0:1
  
  display_aspect_ratio=0:1
  
  pix_fmt=yuv420p
  
  level=13
  
  timecode=N/A
  
  id=N/A
  
  r_frame_rate=50/2
  
  avg_frame_rate=25/1
  
  time_base=1/1200000
  
  start_pts=N/A
  
  start_time=N/A
  
  duration_ts=N/A
  
  duration=N/A
  
  bit_rate=N/A
  
  nb_frames=N/A
  
  nb_read_frames=N/A
  
  nb_read_packets=N/A
  
  DISPOSITION:default=0
  
  DISPOSITION:dub=0
  
  DISPOSITION:original=0
  
  DISPOSITION:comment=0
  
  DISPOSITION:lyrics=0
  
  DISPOSITION:karaoke=0
  
  DISPOSITION:forced=0
  
  DISPOSITION:hearing_impaired=0
  
  DISPOSITION:visual_impaired=0
  
  DISPOSITION:clean_effects=0
  
  DISPOSITION:attached_pic=0
  
  [/STREAM]

  There you can see :

  start_time=N/A
  
  duration_ts=N/A
  
  duration=N/A

  I have tried countless changes to the AVCodecContext and multitude of parameters options to av_opt_set function. Still no luck getting a working H.264 video. I have even tried different builds of FFmpeg. No luck.

  I’m using the "FFmpeg git-0fb64da 32-bit Dev" build from Zeranoe and MinGw 4.7.2