Log to webrtc logging stream from java code.

talk/app/webrtc/java/src/org/webrtc/MediaCodecVideoDecoder.java

 /*
  * libjingle
  * Copyright 2014 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 20 matching lines @@
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
 import android.media.MediaCodecInfo.CodecCapabilities;
 import android.media.MediaCodecList;
 import android.media.MediaFormat;
 import android.opengl.EGL14;
 import android.opengl.EGLContext;
 import android.opengl.GLES11Ext;
 import android.opengl.GLES20;
 import android.os.Build;
-import android.util.Log;
 import android.view.Surface;
 
+import org.webrtc.Logging;
+
 import java.nio.ByteBuffer;
 
 // Java-side of peerconnection_jni.cc:MediaCodecVideoDecoder.
 // This class is an implementation detail of the Java PeerConnection API.
 // MediaCodec is thread-hostile so this class must be operated on a single
 // thread.
 public class MediaCodecVideoDecoder {
   // This class is constructed, operated, and destroyed by its C++ incarnation,
   // so the class and its methods have non-public visibility.  The API this
   // class exposes aims to mimic the webrtc::VideoDecoder API as closely as
@@ skipping 68 matching lines @@
       String name = null;
       for (String mimeType : info.getSupportedTypes()) {
         if (mimeType.equals(mime)) {
           name = info.getName();
           break;
         }
       }
       if (name == null) {
         continue;  // No HW support in this codec; try the next one.
       }
-      Log.v(TAG, "Found candidate decoder " + name);
+      Logging.v(TAG, "Found candidate decoder " + name);
 
       // Check if this is supported decoder.
       boolean supportedCodec = false;
       for (String codecPrefix : supportedCodecPrefixes) {
         if (name.startsWith(codecPrefix)) {
           supportedCodec = true;
           break;
         }
       }
       if (!supportedCodec) {
         continue;
       }
 
       // Check if codec supports either yuv420 or nv12.
       CodecCapabilities capabilities =
           info.getCapabilitiesForType(mime);
       for (int colorFormat : capabilities.colorFormats) {
-        Log.v(TAG, "   Color: 0x" + Integer.toHexString(colorFormat));
+        Logging.v(TAG, "   Color: 0x" + Integer.toHexString(colorFormat));
       }
       for (int supportedColorFormat : supportedColorList) {
         for (int codecColorFormat : capabilities.colorFormats) {
           if (codecColorFormat == supportedColorFormat) {
             // Found supported HW decoder.
-            Log.d(TAG, "Found target decoder " + name +
+            Logging.d(TAG, "Found target decoder " + name +
                 ". Color: 0x" + Integer.toHexString(codecColorFormat));
             return new DecoderProperties(name, codecColorFormat);
           }
         }
       }
     }
     return null;  // No HW decoder.
   }
 
   public static boolean isVp8HwSupported() {
@@ skipping 29 matching lines @@
     } else if (type == VideoCodecType.VIDEO_CODEC_H264) {
       mime = H264_MIME_TYPE;
       supportedCodecPrefixes = supportedH264HwCodecPrefixes;
     } else {
       throw new RuntimeException("Non supported codec " + type);
     }
     DecoderProperties properties = findDecoder(mime, supportedCodecPrefixes);
     if (properties == null) {
       throw new RuntimeException("Cannot find HW decoder for " + type);
     }
-    Log.d(TAG, "Java initDecode: " + type + " : "+ width + " x " + height +
+    Logging.d(TAG, "Java initDecode: " + type + " : "+ width + " x " + height +
         ". Color: 0x" + Integer.toHexString(properties.colorFormat) +
         ". Use Surface: " + useSurface);
     if (sharedContext != null) {
-      Log.d(TAG, "Decoder shared EGL Context: " + sharedContext);
+      Logging.d(TAG, "Decoder shared EGL Context: " + sharedContext);
     }
     mediaCodecThread = Thread.currentThread();
     try {
       Surface decodeSurface = null;
       this.width = width;
       this.height = height;
       this.useSurface = useSurface;
       stride = width;
       sliceHeight = height;
 
       if (useSurface) {
         // Create shared EGL context.
         eglBase = new EglBase(sharedContext, EglBase.ConfigType.PIXEL_BUFFER);
         eglBase.createDummyPbufferSurface();
         eglBase.makeCurrent();
 
         // Create output surface
         textureID = GlUtil.generateTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES);
-        Log.d(TAG, "Video decoder TextureID = " + textureID);
+        Logging.d(TAG, "Video decoder TextureID = " + textureID);
         surfaceTexture = new SurfaceTexture(textureID);
         surface = new Surface(surfaceTexture);
         decodeSurface = surface;
       }
 
       MediaFormat format = MediaFormat.createVideoFormat(mime, width, height);
       if (!useSurface) {
         format.setInteger(MediaFormat.KEY_COLOR_FORMAT, properties.colorFormat);
       }
-      Log.d(TAG, "  Format: " + format);
+      Logging.d(TAG, "  Format: " + format);
       mediaCodec =
           MediaCodecVideoEncoder.createByCodecName(properties.codecName);
       if (mediaCodec == null) {
         return false;
       }
       mediaCodec.configure(format, decodeSurface, null, 0);
       mediaCodec.start();
       colorFormat = properties.colorFormat;
       outputBuffers = mediaCodec.getOutputBuffers();
       inputBuffers = mediaCodec.getInputBuffers();
-      Log.d(TAG, "Input buffers: " + inputBuffers.length +
+      Logging.d(TAG, "Input buffers: " + inputBuffers.length +
           ". Output buffers: " + outputBuffers.length);
       return true;
     } catch (IllegalStateException e) {
-      Log.e(TAG, "initDecode failed", e);
+      Logging.e(TAG, "initDecode failed", e);
       return false;
     }
   }
 
   private void release() {
-    Log.d(TAG, "Java releaseDecoder");
+    Logging.d(TAG, "Java releaseDecoder");
     checkOnMediaCodecThread();
     try {
       mediaCodec.stop();
       mediaCodec.release();
     } catch (IllegalStateException e) {
-      Log.e(TAG, "release failed", e);
+      Logging.e(TAG, "release failed", e);
     }
     mediaCodec = null;
     mediaCodecThread = null;
     if (useSurface) {
       surface.release();
       if (textureID != 0) {
-        Log.d(TAG, "Delete video decoder TextureID " + textureID);
+        Logging.d(TAG, "Delete video decoder TextureID " + textureID);
         GLES20.glDeleteTextures(1, new int[] {textureID}, 0);
         textureID = 0;
       }
       eglBase.release();
       eglBase = null;
     }
   }
 
   // Dequeue an input buffer and return its index, -1 if no input buffer is
   // available, or -2 if the codec is no longer operative.
   private int dequeueInputBuffer() {
     checkOnMediaCodecThread();
     try {
       return mediaCodec.dequeueInputBuffer(DEQUEUE_INPUT_TIMEOUT);
     } catch (IllegalStateException e) {
-      Log.e(TAG, "dequeueIntputBuffer failed", e);
+      Logging.e(TAG, "dequeueIntputBuffer failed", e);
       return -2;
     }
   }
 
   private boolean queueInputBuffer(
       int inputBufferIndex, int size, long timestampUs) {
     checkOnMediaCodecThread();
     try {
       inputBuffers[inputBufferIndex].position(0);
       inputBuffers[inputBufferIndex].limit(size);
       mediaCodec.queueInputBuffer(inputBufferIndex, 0, size, timestampUs, 0);
       return true;
     }
     catch (IllegalStateException e) {
-      Log.e(TAG, "decode failed", e);
+      Logging.e(TAG, "decode failed", e);
       return false;
     }
   }
 
   // Helper struct for dequeueOutputBuffer() below.
   private static class DecoderOutputBufferInfo {
     public DecoderOutputBufferInfo(
         int index, int offset, int size, long presentationTimestampUs) {
       this.index = index;
       this.offset = offset;
@@ skipping 11 matching lines @@
   // buffer available or -2 if error happened.
   private DecoderOutputBufferInfo dequeueOutputBuffer(int dequeueTimeoutUs) {
     checkOnMediaCodecThread();
     try {
       MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
       int result = mediaCodec.dequeueOutputBuffer(info, dequeueTimeoutUs);
       while (result == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED ||
           result == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
         if (result == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
           outputBuffers = mediaCodec.getOutputBuffers();
-          Log.d(TAG, "Decoder output buffers changed: " + outputBuffers.length);
+          Logging.d(TAG, "Decoder output buffers changed: " + outputBuffers.length);
         } else if (result == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
           MediaFormat format = mediaCodec.getOutputFormat();
-          Log.d(TAG, "Decoder format changed: " + format.toString());
+          Logging.d(TAG, "Decoder format changed: " + format.toString());
           width = format.getInteger(MediaFormat.KEY_WIDTH);
           height = format.getInteger(MediaFormat.KEY_HEIGHT);
           if (!useSurface && format.containsKey(MediaFormat.KEY_COLOR_FORMAT)) {
             colorFormat = format.getInteger(MediaFormat.KEY_COLOR_FORMAT);
-            Log.d(TAG, "Color: 0x" + Integer.toHexString(colorFormat));
+            Logging.d(TAG, "Color: 0x" + Integer.toHexString(colorFormat));
             // Check if new color space is supported.
             boolean validColorFormat = false;
             for (int supportedColorFormat : supportedColorList) {
               if (colorFormat == supportedColorFormat) {
                 validColorFormat = true;
                 break;
               }
             }
             if (!validColorFormat) {
-              Log.e(TAG, "Non supported color format");
+              Logging.e(TAG, "Non supported color format");
               return new DecoderOutputBufferInfo(-1, 0, 0, -1);
             }
           }
           if (format.containsKey("stride")) {
             stride = format.getInteger("stride");
           }
           if (format.containsKey("slice-height")) {
             sliceHeight = format.getInteger("slice-height");
           }
-          Log.d(TAG, "Frame stride and slice height: "
+          Logging.d(TAG, "Frame stride and slice height: "
               + stride + " x " + sliceHeight);
           stride = Math.max(width, stride);
           sliceHeight = Math.max(height, sliceHeight);
         }
         result = mediaCodec.dequeueOutputBuffer(info, dequeueTimeoutUs);
       }
       if (result >= 0) {
         return new DecoderOutputBufferInfo(result, info.offset, info.size,
             info.presentationTimeUs);
       }
       return null;
     } catch (IllegalStateException e) {
-      Log.e(TAG, "dequeueOutputBuffer failed", e);
+      Logging.e(TAG, "dequeueOutputBuffer failed", e);
       return new DecoderOutputBufferInfo(-1, 0, 0, -1);
     }
   }
 
   // Release a dequeued output buffer back to the codec for re-use.  Return
   // false if the codec is no longer operable.
   private boolean releaseOutputBuffer(int index, boolean render) {
     checkOnMediaCodecThread();
     try {
       if (!useSurface) {
         render = false;
       }
       mediaCodec.releaseOutputBuffer(index, render);
       return true;
     } catch (IllegalStateException e) {
-      Log.e(TAG, "releaseOutputBuffer failed", e);
+      Logging.e(TAG, "releaseOutputBuffer failed", e);
       return false;
     }
   }
 }