1 /*
   2  * Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.webkit.graphics;
  27 
  28 import java.util.logging.Level;
  29 import java.util.logging.Logger;
  30 import com.sun.webkit.Invoker;
  31 
  32 public abstract class WCMediaPlayer extends Ref {
  33 
  34     protected final static Logger log;
  35     protected final static boolean verbose;
  36 
  37     static {
  38         log = Logger.getLogger("webkit.mediaplayer");
  39         if (log.getLevel() == null) {
  40             // disable logging if webkit.mediaplayer.level
  41             // is not specified (explicitly) in log config file
  42             verbose = false;
  43             log.setLevel(Level.OFF);
  44         } else {
  45             verbose = true;
  46             log.log(Level.CONFIG, "webkit.mediaplayer logging is ON, level: {0}", log.getLevel());
  47         }
  48     }
  49 
  50     // pointer to native Player object;
  51     // read the value only on FX event thread, check that it has non-zero value;
  52     // setters (ctor && fwkDispose) are called on event thread.
  53     private long nPtr;
  54 
  55     protected WCMediaPlayer() {
  56     }
  57 
  58     void setNativePointer(long nativePointer) {
  59         if (nativePointer == 0) {
  60             throw new IllegalArgumentException("nativePointer is 0");
  61         }
  62         if (nPtr != 0) {
  63             throw new IllegalStateException("nPtr is not 0");
  64         }
  65         this.nPtr = nativePointer;
  66     }
  67 
  68     /**
  69      * Methods to implement
  70      */
  71     protected abstract void load(String url, String userAgent);
  72     protected abstract void cancelLoad();
  73     protected abstract void disposePlayer();
  74 
  75     protected abstract void prepareToPlay();
  76     protected abstract void play();
  77     protected abstract void pause();
  78 
  79     protected abstract float getCurrentTime();
  80     // the method _must_ call notifySeeking(true)/notifySeeking(false)
  81     protected abstract void seek(float time);
  82     protected abstract void setRate(float rate);
  83     protected abstract void setVolume(float volume);
  84     protected abstract void setMute(boolean mute);
  85     protected abstract void setSize(int w, int h);
  86     protected abstract void setPreservesPitch(boolean preserve);
  87 
  88     protected abstract void renderCurrentFrame(WCGraphicsContext gc, int x, int y, int w, int h);
  89 
  90     /**
  91      * Obtains current "preserves pitch" value.
  92      */
  93     protected boolean getPreservesPitch() {
  94         return preserve;
  95     }
  96 
  97     protected int getNetworkState() {
  98         return networkState;
  99     }
 100 
 101     protected int getReadyState() {
 102         return readyState;
 103     }
 104 
 105     protected int getPreload() {
 106         return preload;
 107     }
 108 
 109     protected boolean isPaused() {
 110         return paused;
 111     }
 112 
 113     protected boolean isSeeking() {
 114         return seeking;
 115     }
 116 
 117 
 118     /* ======================================= */
 119     /*  Methods to notify webkit about events  */
 120     /* ======================================= */
 121     //enum NetworkState { Empty, Idle, Loading, Loaded, FormatError, NetworkError, DecodeError };
 122     protected final static int NETWORK_STATE_EMPTY              = 0;
 123     protected final static int NETWORK_STATE_IDLE               = 1;
 124     protected final static int NETWORK_STATE_LOADING            = 2;
 125     protected final static int NETWORK_STATE_LOADED             = 3;
 126     protected final static int NETWORK_STATE_FORMAT_ERROR       = 4;
 127     protected final static int NETWORK_STATE_NETWORK_ERROR      = 5;
 128     protected final static int NETWORK_STATE_DECODE_ERROR       = 6;
 129     //enum ReadyState  { HaveNothing, HaveMetadata, HaveCurrentData, HaveFutureData, HaveEnoughData };
 130     protected final static int READY_STATE_HAVE_NOTHING         = 0;
 131     protected final static int READY_STATE_HAVE_METADATA        = 1;
 132     protected final static int READY_STATE_HAVE_CURRENT_DATA    = 2;
 133     protected final static int READY_STATE_HAVE_FUTURE_DATA     = 3;
 134     protected final static int READY_STATE_HAVE_ENOUGH_DATA     = 4;
 135     //enum Preload { None, MetaData, Auto };
 136     protected final static int PRELOAD_NONE                     = 0;
 137     protected final static int PRELOAD_METADATA                 = 1;
 138     protected final static int PRELOAD_AUTO                     = 2;
 139 
 140     private int networkState = NETWORK_STATE_EMPTY;
 141     private int readyState = READY_STATE_HAVE_NOTHING;
 142     private int preload = PRELOAD_AUTO;
 143     private boolean paused = true;
 144     private boolean seeking = false;
 145 
 146 
 147     protected void notifyNetworkStateChanged(int networkState) {
 148         if (this.networkState != networkState) {
 149             this.networkState = networkState;
 150             final int _networkState = networkState;
 151             Invoker.getInvoker().invokeOnEventThread(() -> {
 152                 if (nPtr != 0) {
 153                     notifyNetworkStateChanged(nPtr, _networkState);
 154                 }
 155             });
 156         }
 157     }
 158 
 159     protected void notifyReadyStateChanged(int readyState) {
 160         if (this.readyState != readyState) {
 161             this.readyState = readyState;
 162             final int _readyState = readyState;
 163             Invoker.getInvoker().invokeOnEventThread(() -> {
 164                 if (nPtr != 0) {
 165                     notifyReadyStateChanged(nPtr, _readyState);
 166                 }
 167             });
 168         }
 169     }
 170 
 171     protected void notifyPaused(boolean paused) {
 172         if (verbose) log.log(Level.FINE, "notifyPaused, {0} => {1}",
 173                 new Object[]{Boolean.valueOf(this.paused), Boolean.valueOf(paused)});
 174         if (this.paused != paused) {
 175             this.paused = paused;
 176             final boolean _paused = paused;
 177             Invoker.getInvoker().invokeOnEventThread(() -> {
 178                 if (nPtr != 0) {
 179                     notifyPaused(nPtr, _paused);
 180                 }
 181             });
 182         }
 183     }
 184 
 185     // pass -1 as readyState value if the state is not changed
 186     protected void notifySeeking(boolean seeking, int readyState) {
 187         if (verbose) log.log(Level.FINE, "notifySeeking, {0} => {1}",
 188                 new Object[]{Boolean.valueOf(this.seeking), Boolean.valueOf(seeking)});
 189         if (this.seeking != seeking || this.readyState != readyState) {
 190             this.seeking = seeking;
 191             this.readyState = readyState;
 192             final boolean _seeking = seeking;
 193             final int _readyState = readyState;
 194             Invoker.getInvoker().invokeOnEventThread(() -> {
 195                 if (nPtr != 0) {
 196                     notifySeeking(nPtr, _seeking, _readyState);
 197                 }
 198             });
 199         }
 200     }
 201 
 202     protected void notifyFinished() {
 203         Invoker.getInvoker().invokeOnEventThread(() -> {
 204             if (nPtr != 0) {
 205                 notifyFinished(nPtr);
 206             }
 207         });
 208     }
 209 
 210     /** got metadata */
 211     protected void notifyReady(boolean hasVideo, boolean hasAudio, float duration) {
 212         final boolean _hasVideo = hasVideo;
 213         final boolean _hasAudio = hasAudio;
 214         final float _duration = duration;
 215         Invoker.getInvoker().invokeOnEventThread(() -> {
 216             if (nPtr != 0) {
 217                 notifyReady(nPtr, _hasVideo, _hasAudio, _duration);
 218             }
 219         });
 220     }
 221 
 222     protected void notifyDurationChanged(float newDuration) {
 223         final float _newDuration = newDuration;
 224         Invoker.getInvoker().invokeOnEventThread(() -> {
 225             if (nPtr != 0) {
 226                 notifyDurationChanged(nPtr, _newDuration);
 227             }
 228         });
 229     }
 230 
 231     protected void notifySizeChanged(int width, int height) {
 232         // notify on event thread to ensure native object is valid (nPtr != 0)
 233         final int _width = width;
 234         final int _height = height;
 235         Invoker.getInvoker().invokeOnEventThread(() -> {
 236             if (nPtr != 0) {
 237                 notifySizeChanged(nPtr, _width, _height);
 238             }
 239         });
 240     }
 241 
 242     private Runnable newFrameNotifier = () -> {
 243         if (nPtr != 0) {
 244             notifyNewFrame(nPtr);
 245         }
 246     };
 247 
 248     protected void notifyNewFrame() {
 249         Invoker.getInvoker().invokeOnEventThread(newFrameNotifier);
 250     }
 251 
 252     /** {@code ranges} array contains pairs [start,end] of the buffered times */
 253     protected void notifyBufferChanged(float[] ranges, int bytesLoaded) {
 254         // notify on event thread to ensure native object is valid (nPtr != 0)
 255         final float[] _ranges = ranges;
 256         final int _bytesLoaded = bytesLoaded;
 257         Invoker.getInvoker().invokeOnEventThread(() -> {
 258             if (nPtr != 0) {
 259                 notifyBufferChanged(nPtr, _ranges, _bytesLoaded);
 260             }
 261         });
 262     }
 263 
 264 
 265     /* ======================================= */
 266     /*  Methods called from webkit             */
 267     /* ======================================= */
 268 
 269     private void fwkLoad(String url, String userAgent) {
 270         if (verbose) log.log(Level.FINE, "fwkLoad, url={0}, userAgent={1}", new Object[] {url, userAgent});
 271         load(url, userAgent);
 272     }
 273 
 274     private void fwkCancelLoad() {
 275         if (verbose) log.log(Level.FINE, "fwkCancelLoad");
 276         cancelLoad();
 277     }
 278 
 279     private void fwkPrepareToPlay() {
 280         if (verbose) log.log(Level.FINE, "fwkPrepareToPlay");
 281         prepareToPlay();
 282     }
 283 
 284     private void fwkDispose() {
 285         if (verbose) log.log(Level.FINE, "fwkDispose");
 286         nPtr = 0;
 287         cancelLoad();
 288         disposePlayer();
 289     }
 290 
 291     private void fwkPlay() {
 292         if (verbose) log.log(Level.FINE, "fwkPlay");
 293         play();
 294     }
 295 
 296     private void fwkPause() {
 297         if (verbose) log.log(Level.FINE, "fwkPause");
 298         pause();
 299     }
 300 
 301     private float fwkGetCurrentTime() {
 302         float res = getCurrentTime();
 303         if (verbose) log.log(Level.FINER, "fwkGetCurrentTime(), return {0}", res);
 304         return res;
 305     }
 306 
 307     private void fwkSeek(float time) {
 308         if (verbose) log.log(Level.FINE, "fwkSeek({0})", time);
 309         seek(time);
 310     }
 311 
 312     private void fwkSetRate(float rate) {
 313         if (verbose) log.log(Level.FINE, "fwkSetRate({0})", rate);
 314         setRate(rate);
 315     }
 316 
 317     private void fwkSetVolume(float volume) {
 318         if (verbose) log.log(Level.FINE, "fwkSetVolume({0})", volume);
 319         setVolume(volume);
 320     }
 321 
 322     private void fwkSetMute(boolean mute) {
 323         if (verbose) log.log(Level.FINE, "fwkSetMute({0})", mute);
 324         setMute(mute);
 325     }
 326 
 327     private void fwkSetSize(int w, int h) {
 328         //if (verbose) log.log(Level.FINE, "setSize({0} x {1})", new Object[]{w, h});
 329         setSize(w, h);
 330     }
 331 
 332     private boolean preserve = true;
 333 
 334     private void fwkSetPreservesPitch(boolean preserve) {
 335         if (verbose) log.log(Level.FINE, "setPreservesPitch({0})", preserve);
 336 //        synchronized(renderLock) {
 337             this.preserve = preserve;
 338             setPreservesPitch(preserve);
 339 //        }
 340     }
 341 
 342     private void fwkSetPreload(int preload) {
 343         if (verbose) {
 344             log.log(Level.FINE, "fwkSetPreload({0})",
 345                     preload == PRELOAD_NONE ? "PRELOAD_NONE"
 346                     : preload == PRELOAD_METADATA ? "PRELOAD_METADATA"
 347                     : preload == PRELOAD_AUTO ? "PRELOAD_AUTO"
 348                     : ("INVALID VALUE: " + preload));
 349         }
 350         this.preload = preload;
 351     }
 352 
 353     /* called from GraphicsDecoder */
 354     void render(WCGraphicsContext gc, int x, int y, int w, int h) {
 355         if (verbose) {
 356             log.log(Level.FINER, "render(x={0}, y={1}, w={2}, h={3}",
 357                     new Object[]{x, y, w, h});
 358         }
 359         renderCurrentFrame(gc, x, y, w, h);
 360     }
 361 
 362 
 363     /* native methods */
 364     private native void notifyNetworkStateChanged(long nPtr, int networkState);
 365     private native void notifyReadyStateChanged(long nPtr, int readyState);
 366     private native void notifyPaused(long nPtr, boolean paused);
 367     private native void notifySeeking(long nPtr, boolean seeking, int readyState);
 368     private native void notifyFinished(long nPtr);
 369     private native void notifyReady(long nPtr, boolean hasVideo, boolean hasAudio, float duration);
 370     private native void notifyDurationChanged(long nPtr, float duration);
 371     private native void notifySizeChanged(long nPtr, int width, int height);
 372     private native void notifyNewFrame(long nPtr);
 373     private native void notifyBufferChanged(long nPtr, float[] ranges, int bytesLoaded);
 374 
 375 }