Log to webrtc logging stream from java code.

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

 /*
  * libjingle
  * Copyright 2013 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 17 matching lines @@
 
 package org.webrtc;
 
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo.CodecCapabilities;
 import android.media.MediaCodecInfo;
 import android.media.MediaCodecList;
 import android.media.MediaFormat;
 import android.os.Build;
 import android.os.Bundle;
-import android.util.Log;
+
+import org.webrtc.Logging;
 
 import java.nio.ByteBuffer;
 import java.util.Arrays;
 import java.util.List;
 
 // Java-side of peerconnection_jni.cc:MediaCodecVideoEncoder.
 // 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 MediaCodecVideoEncoder {
@@ skipping 69 matching lines @@
     // MediaCodec.setParameters is missing for JB and below, so bitrate
     // can not be adjusted dynamically.
     if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
       return null;
     }
 
     // Check if device is in H.264 exception list.
     if (mime.equals(H264_MIME_TYPE)) {
       List<String> exceptionModels = Arrays.asList(H264_HW_EXCEPTION_MODELS);
       if (exceptionModels.contains(Build.MODEL)) {
-        Log.w(TAG, "Model: " + Build.MODEL +
+        Logging.w(TAG, "Model: " + Build.MODEL +
             " has black listed H.264 encoder.");
         return null;
       }
     }
 
     for (int i = 0; i < MediaCodecList.getCodecCount(); ++i) {
       MediaCodecInfo info = MediaCodecList.getCodecInfoAt(i);
       if (!info.isEncoder()) {
         continue;
       }
       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 encoder " + name);
+      Logging.v(TAG, "Found candidate encoder " + name);
 
       // Check if this is supported HW encoder.
       boolean supportedCodec = false;
       for (String hwCodecPrefix : supportedHwCodecPrefixes) {
         if (name.startsWith(hwCodecPrefix)) {
           supportedCodec = true;
           break;
         }
       }
       if (!supportedCodec) {
         continue;
       }
 
       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));
       }
 
       // Check if codec supports either yuv420 or nv12.
       for (int supportedColorFormat : supportedColorList) {
         for (int codecColorFormat : capabilities.colorFormats) {
           if (codecColorFormat == supportedColorFormat) {
             // Found supported HW encoder.
-            Log.d(TAG, "Found target encoder for mime " + mime + " : " + name +
+            Logging.d(TAG, "Found target encoder for mime " + mime + " : " + name +
                 ". Color: 0x" + Integer.toHexString(codecColorFormat));
             return new EncoderProperties(name, codecColorFormat);
           }
         }
       }
     }
     return null;  // No HW VP8 encoder.
   }
 
   public static boolean isVp8HwSupported() {
@@ skipping 18 matching lines @@
       // both cases catch an exception.
       return MediaCodec.createByCodecName(codecName);
     } catch (Exception e) {
       return null;
     }
   }
 
   // Return the array of input buffers, or null on failure.
   private ByteBuffer[] initEncode(
       VideoCodecType type, int width, int height, int kbps, int fps) {
-    Log.d(TAG, "Java initEncode: " + type + " : " + width + " x " + height +
+    Logging.d(TAG, "Java initEncode: " + type + " : " + width + " x " + height +
         ". @ " + kbps + " kbps. Fps: " + fps +
         ". Color: 0x" + Integer.toHexString(colorFormat));
     if (mediaCodecThread != null) {
       throw new RuntimeException("Forgot to release()?");
     }
     this.type = type;
     EncoderProperties properties = null;
     String mime = null;
     int keyFrameIntervalSec = 0;
     if (type == VideoCodecType.VIDEO_CODEC_VP8) {
       mime = VP8_MIME_TYPE;
       properties = findHwEncoder(VP8_MIME_TYPE, supportedVp8HwCodecPrefixes);
       keyFrameIntervalSec = 100;
     } else if (type == VideoCodecType.VIDEO_CODEC_H264) {
       mime = H264_MIME_TYPE;
       properties = findHwEncoder(H264_MIME_TYPE, supportedH264HwCodecPrefixes);
       keyFrameIntervalSec = 20;
     }
     if (properties == null) {
       throw new RuntimeException("Can not find HW encoder for " + type);
     }
     mediaCodecThread = Thread.currentThread();
     try {
       MediaFormat format = MediaFormat.createVideoFormat(mime, width, height);
       format.setInteger(MediaFormat.KEY_BIT_RATE, 1000 * kbps);
       format.setInteger("bitrate-mode", VIDEO_ControlRateConstant);
       format.setInteger(MediaFormat.KEY_COLOR_FORMAT, properties.colorFormat);
       format.setInteger(MediaFormat.KEY_FRAME_RATE, fps);
       format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, keyFrameIntervalSec);
-      Log.d(TAG, "  Format: " + format);
+      Logging.d(TAG, "  Format: " + format);
       mediaCodec = createByCodecName(properties.codecName);
       if (mediaCodec == null) {
         return null;
       }
       mediaCodec.configure(
           format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
       mediaCodec.start();
       colorFormat = properties.colorFormat;
       outputBuffers = mediaCodec.getOutputBuffers();
       ByteBuffer[] inputBuffers = mediaCodec.getInputBuffers();
-      Log.d(TAG, "Input buffers: " + inputBuffers.length +
+      Logging.d(TAG, "Input buffers: " + inputBuffers.length +
           ". Output buffers: " + outputBuffers.length);
       return inputBuffers;
     } catch (IllegalStateException e) {
-      Log.e(TAG, "initEncode failed", e);
+      Logging.e(TAG, "initEncode failed", e);
       return null;
     }
   }
 
   private boolean encode(
       boolean isKeyframe, int inputBuffer, int size,
       long presentationTimestampUs) {
     checkOnMediaCodecThread();
     try {
       if (isKeyframe) {
         // Ideally MediaCodec would honor BUFFER_FLAG_SYNC_FRAME so we could
         // indicate this in queueInputBuffer() below and guarantee _this_ frame
         // be encoded as a key frame, but sadly that flag is ignored.  Instead,
         // we request a key frame "soon".
-        Log.d(TAG, "Sync frame request");
+        Logging.d(TAG, "Sync frame request");
         Bundle b = new Bundle();
         b.putInt(MediaCodec.PARAMETER_KEY_REQUEST_SYNC_FRAME, 0);
         mediaCodec.setParameters(b);
       }
       mediaCodec.queueInputBuffer(
           inputBuffer, 0, size, presentationTimestampUs, 0);
       return true;
     }
     catch (IllegalStateException e) {
-      Log.e(TAG, "encode failed", e);
+      Logging.e(TAG, "encode failed", e);
       return false;
     }
   }
 
   private void release() {
-    Log.d(TAG, "Java releaseEncoder");
+    Logging.d(TAG, "Java releaseEncoder");
     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;
   }
 
   private boolean setRates(int kbps, int frameRateIgnored) {
     // frameRate argument is ignored - HW encoder is supposed to use
     // video frame timestamps for bit allocation.
     checkOnMediaCodecThread();
-    Log.v(TAG, "setRates: " + kbps + " kbps. Fps: " + frameRateIgnored);
+    Logging.v(TAG, "setRates: " + kbps + " kbps. Fps: " + frameRateIgnored);
     try {
       Bundle params = new Bundle();
       params.putInt(MediaCodec.PARAMETER_KEY_VIDEO_BITRATE, 1000 * kbps);
       mediaCodec.setParameters(params);
       return true;
     } catch (IllegalStateException e) {
-      Log.e(TAG, "setRates failed", e);
+      Logging.e(TAG, "setRates failed", e);
       return false;
     }
   }
 
   // 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_TIMEOUT);
     } catch (IllegalStateException e) {
-      Log.e(TAG, "dequeueIntputBuffer failed", e);
+      Logging.e(TAG, "dequeueIntputBuffer failed", e);
       return -2;
     }
   }
 
   // Helper struct for dequeueOutputBuffer() below.
   private static class OutputBufferInfo {
     public OutputBufferInfo(
         int index, ByteBuffer buffer,
         boolean isKeyFrame, long presentationTimestampUs) {
       this.index = index;
@@ skipping 13 matching lines @@
   private OutputBufferInfo dequeueOutputBuffer() {
     checkOnMediaCodecThread();
     try {
       MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
       int result = mediaCodec.dequeueOutputBuffer(info, DEQUEUE_TIMEOUT);
       // Check if this is config frame and save configuration data.
       if (result >= 0) {
         boolean isConfigFrame =
             (info.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0;
         if (isConfigFrame) {
-          Log.d(TAG, "Config frame generated. Offset: " + info.offset +
+          Logging.d(TAG, "Config frame generated. Offset: " + info.offset +
               ". Size: " + info.size);
           configData = ByteBuffer.allocateDirect(info.size);
           outputBuffers[result].position(info.offset);
           outputBuffers[result].limit(info.offset + info.size);
           configData.put(outputBuffers[result]);
           // Release buffer back.
           mediaCodec.releaseOutputBuffer(result, false);
           // Query next output.
           result = mediaCodec.dequeueOutputBuffer(info, DEQUEUE_TIMEOUT);
         }
       }
       if (result >= 0) {
         // MediaCodec doesn't care about Buffer position/remaining/etc so we can
         // mess with them to get a slice and avoid having to pass extra
         // (BufferInfo-related) parameters back to C++.
         ByteBuffer outputBuffer = outputBuffers[result].duplicate();
         outputBuffer.position(info.offset);
         outputBuffer.limit(info.offset + info.size);
         // Check key frame flag.
         boolean isKeyFrame =
             (info.flags & MediaCodec.BUFFER_FLAG_SYNC_FRAME) != 0;
         if (isKeyFrame) {
-          Log.d(TAG, "Sync frame generated");
+          Logging.d(TAG, "Sync frame generated");
         }
         if (isKeyFrame && type == VideoCodecType.VIDEO_CODEC_H264) {
-          Log.d(TAG, "Appending config frame of size " + configData.capacity() +
+          Logging.d(TAG, "Appending config frame of size " + configData.capacity() +
               " to output buffer with offset " + info.offset + ", size " +
               info.size);
           // For H.264 key frame append SPS and PPS NALs at the start
           ByteBuffer keyFrameBuffer = ByteBuffer.allocateDirect(
               configData.capacity() + info.size);
           configData.rewind();
           keyFrameBuffer.put(configData);
           keyFrameBuffer.put(outputBuffer);
           keyFrameBuffer.position(0);
           return new OutputBufferInfo(result, keyFrameBuffer,
               isKeyFrame, info.presentationTimeUs);
         } else {
           return new OutputBufferInfo(result, outputBuffer.slice(),
               isKeyFrame, info.presentationTimeUs);
         }
       } else if (result == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
         outputBuffers = mediaCodec.getOutputBuffers();
         return dequeueOutputBuffer();
       } else if (result == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
         return dequeueOutputBuffer();
       } else if (result == MediaCodec.INFO_TRY_AGAIN_LATER) {
         return null;
       }
       throw new RuntimeException("dequeueOutputBuffer: " + result);
     } catch (IllegalStateException e) {
-      Log.e(TAG, "dequeueOutputBuffer failed", e);
+      Logging.e(TAG, "dequeueOutputBuffer failed", e);
       return new OutputBufferInfo(-1, null, false, -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) {
     checkOnMediaCodecThread();
     try {
       mediaCodec.releaseOutputBuffer(index, false);
       return true;
     } catch (IllegalStateException e) {
-      Log.e(TAG, "releaseOutputBuffer failed", e);
+      Logging.e(TAG, "releaseOutputBuffer failed", e);
       return false;
     }
   }
 }