diff options
Diffstat (limited to 'src/jogl/classes')
| -rw-r--r-- | src/jogl/classes/jogamp/opengl/util/av/impl/FFMPEGDynamicLibraryBundleInfo.java | 219 | ||||
| -rw-r--r-- | src/jogl/classes/jogamp/opengl/util/av/impl/FFMPEGMediaPlayer.java | 503 |
2 files changed, 722 insertions, 0 deletions
diff --git a/src/jogl/classes/jogamp/opengl/util/av/impl/FFMPEGDynamicLibraryBundleInfo.java b/src/jogl/classes/jogamp/opengl/util/av/impl/FFMPEGDynamicLibraryBundleInfo.java new file mode 100644 index 000000000..4c4870545 --- /dev/null +++ b/src/jogl/classes/jogamp/opengl/util/av/impl/FFMPEGDynamicLibraryBundleInfo.java @@ -0,0 +1,219 @@ +/** + * Copyright 2012 JogAmp Community. All rights reserved. + * + * 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, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of JogAmp Community. + */ + +package jogamp.opengl.util.av.impl; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import javax.media.opengl.GLProfile; + +import com.jogamp.common.os.DynamicLibraryBundle; +import com.jogamp.common.os.DynamicLibraryBundleInfo; +import com.jogamp.common.util.RunnableExecutor; + +class FFMPEGDynamicLibraryBundleInfo implements DynamicLibraryBundleInfo { + private static List<String> glueLibNames = new ArrayList<String>(); // none + + private static final int symbolCount = 29; + private static String[] symbolNames = { + "avcodec_version", + "avformat_version", +/* 3 */ "avutil_version", + + // libavcodec + "avcodec_close", + "avcodec_string", + "avcodec_find_decoder", + "avcodec_open2", // 53.6.0 (opt) + "avcodec_open", + "avcodec_alloc_frame", + "avcodec_default_get_buffer", + "avcodec_default_release_buffer", + "av_free_packet", + "avcodec_decode_audio4", // 53.25.0 (opt) + "avcodec_decode_audio3", // 52.23.0 +/* 15 */ "avcodec_decode_video2", // 52.23.0 + + // libavutil + "av_pix_fmt_descriptors", + "av_free", +/* 18 */ "av_get_bits_per_pixel", + + // libavformat + "avformat_close_input", // 53.17.0 (opt) + "av_close_input_file", + "av_register_all", + "avformat_open_input", + "av_dump_format", + "av_read_frame", + "av_seek_frame", + "avformat_network_init", // 53.13.0 (opt) + "avformat_network_deinit", // 53.13.0 (opt) + "avformat_find_stream_info", // 53.3.0 (opt) +/* 29 */ "av_find_stream_info" + }; + + private static String[] optionalSymbolNames = { + "avcodec_open2", // 53.6.0 (opt) + "avcodec_decode_audio4", // 53.25.0 (opt) + "avformat_close_input", // 53.17.0 (opt) + "avformat_network_init", // 53.13.0 (opt) + "avformat_network_deinit", // 53.13.0 (opt) + "avformat_find_stream_info" // 53.3.0 (opt) + }; + + private static long[] symbolAddr; + private static final boolean ready; + + static { + // native ffmpeg media player implementation is included in jogl_desktop and jogl_mobile + GLProfile.initSingleton(); + boolean _ready = false; + try { + _ready = initSymbols(); + } catch (Throwable t) { + t.printStackTrace(); + } + ready = _ready; + if(!ready) { + System.err.println("FFMPEG: Not Available"); + } + } + + static boolean initSingleton() { return ready; } + + private static boolean initSymbols() { + final DynamicLibraryBundle dl = new DynamicLibraryBundle(new FFMPEGDynamicLibraryBundleInfo()); + final boolean avutilLoaded = dl.isToolLibLoaded(0); + final boolean avformatLoaded = dl.isToolLibLoaded(1); + final boolean avcodecLoaded = dl.isToolLibLoaded(2); + if(!avutilLoaded || !avformatLoaded || !avcodecLoaded) { + throw new RuntimeException("FFMPEG Tool library incomplete: [ avutil "+avutilLoaded+", avformat "+avformatLoaded+", avcodec "+avcodecLoaded+"]"); + } + if(!dl.isToolLibComplete()) { + throw new RuntimeException("FFMPEG Tool libraries incomplete"); + } + symbolAddr = new long[symbolCount]; + + final Set<String> optionalSet = new HashSet<String>(); + optionalSet.addAll(Arrays.asList(optionalSymbolNames)); + + if(!lookupSymbols(dl, symbolNames, optionalSet, symbolAddr, symbolCount)) { + return false; + } + return initSymbols0(symbolAddr, symbolAddr.length); + } + + private static boolean lookupSymbols(DynamicLibraryBundle dl, + String[] symbols, Set<String> optionalSymbols, + long[] addresses, int symbolCount) { + for(int i = 0; i<symbolCount; i++) { + final long addr = dl.dynamicLookupFunction(symbols[i]); + if( 0 == addr ) { + if(!optionalSymbols.contains(symbols[i])) { + System.err.println("Could not resolve mandatory symbol <"+symbols[i]+">"); + return false; + } else if(true || DEBUG ) { // keep it verbose per default for now .. + System.err.println("Could not resolve optional symbol <"+symbols[i]+">"); + } + } + addresses[i] = addr; + } + return true; + } + + protected FFMPEGDynamicLibraryBundleInfo() { + } + + @Override + public boolean shallLinkGlobal() { return true; } + + @Override + public boolean shallLookupGlobal() { return true; } + + @Override + public final List<String> getGlueLibNames() { + return glueLibNames; + } + + @Override + public List<List<String>> getToolLibNames() { + List<List<String>> libsList = new ArrayList<List<String>>(); + + final List<String> avutil = new ArrayList<String>(); + avutil.add("avutil"); // default + avutil.add("avutil-52"); // dummy future proof + avutil.add("avutil-51"); // 0.8 + avutil.add("avutil-50"); // 0.7 + libsList.add(avutil); + + final List<String> avformat = new ArrayList<String>(); + avformat.add("avformat"); // default + avformat.add("avformat-55"); // dummy future proof + avformat.add("avformat-54"); // 0.? + avformat.add("avformat-53"); // 0.8 + avformat.add("avformat-52"); // 0.7 + libsList.add(avformat); + + final List<String> avcodec = new ArrayList<String>(); + avcodec.add("avcodec"); // default + avcodec.add("avcodec-55"); // dummy future proof + avcodec.add("avcodec-54"); // 0.? + avcodec.add("avcodec-53"); // 0.8 + avcodec.add("avcodec-52"); // 0.7 + libsList.add(avcodec); + + return libsList; + } + + @Override + public final List<String> getToolGetProcAddressFuncNameList() { + return null; + } + + @Override + public final long toolGetProcAddress(long toolGetProcAddressHandle, String funcName) { + return 0; + } + + @Override + public boolean useToolGetProcAdressFirst(String funcName) { + return false; + } + + @Override + public RunnableExecutor getLibLoaderExecutor() { + return DynamicLibraryBundle.getDefaultRunnableExecutor(); + } + + private static native boolean initSymbols0(long[] symbols, int count); +} diff --git a/src/jogl/classes/jogamp/opengl/util/av/impl/FFMPEGMediaPlayer.java b/src/jogl/classes/jogamp/opengl/util/av/impl/FFMPEGMediaPlayer.java new file mode 100644 index 000000000..d24961b68 --- /dev/null +++ b/src/jogl/classes/jogamp/opengl/util/av/impl/FFMPEGMediaPlayer.java @@ -0,0 +1,503 @@ +/** + * Copyright 2012 JogAmp Community. All rights reserved. + * + * 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, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of JogAmp Community. + */ + +package jogamp.opengl.util.av.impl; + +import java.io.IOException; +import java.nio.Buffer; +import java.nio.ByteBuffer; + +import javax.media.opengl.GL; +import javax.media.opengl.GL2ES2; +import javax.media.opengl.GLException; + +import com.jogamp.common.util.VersionNumber; +import com.jogamp.gluegen.runtime.ProcAddressTable; +import com.jogamp.opengl.util.GLPixelStorageModes; +import com.jogamp.opengl.util.texture.Texture; +import com.jogamp.opengl.util.texture.TextureSequence; + +import jogamp.opengl.GLContextImpl; +import jogamp.opengl.es1.GLES1ProcAddressTable; +import jogamp.opengl.es2.GLES2ProcAddressTable; +import jogamp.opengl.gl4.GL4bcProcAddressTable; +import jogamp.opengl.util.av.EGLMediaPlayerImpl; + +/*** + * Currently only YUV420P and the usual packed RGB formats are supported. + * <p> + * Check tag 'FIXME: Add more planar formats !' + * here and in the corresponding native code + * <code>jogl/src/jogl/native/ffmpeg/jogamp_opengl_util_av_impl_FFMPEGMediaPlayer.c</code> + * </p> + * <p> + * TODO: Audio Output + * </p> + */ +public class FFMPEGMediaPlayer extends EGLMediaPlayerImpl { + public static final VersionNumber avUtilVersion; + public static final VersionNumber avFormatVersion; + public static final VersionNumber avCodecVersion; + static final boolean available; + + static { + if(FFMPEGDynamicLibraryBundleInfo.initSingleton()) { + avUtilVersion = getAVVersion(getAvUtilVersion0()); + avFormatVersion = getAVVersion(getAvFormatVersion0()); + avCodecVersion = getAVVersion(getAvCodecVersion0()); + System.err.println("LIB_AV Util : "+avUtilVersion); + System.err.println("LIB_AV Format: "+avFormatVersion); + System.err.println("LIB_AV Codec : "+avCodecVersion); + available = initIDs0(); + } else { + avUtilVersion = null; + avFormatVersion = null; + avCodecVersion = null; + available = false; + } + } + + public static final boolean isAvailable() { return available; } + + private static VersionNumber getAVVersion(int vers) { + return new VersionNumber( ( vers >> 16 ) & 0xFF, + ( vers >> 8 ) & 0xFF, + ( vers >> 0 ) & 0xFF ); + } + + protected long moviePtr = 0; + protected long procAddrGLTexSubImage2D = 0; + protected EGLMediaPlayerImpl.EGLTextureFrame lastTex = null; + protected GLPixelStorageModes psm; + protected PixelFormat vPixelFmt = null; + protected int vPlanes = 0; + protected int vBitsPerPixel = 0; + protected int vBytesPerPixelPerPlane = 0; + protected int[] vLinesize = { 0, 0, 0 }; // per plane + protected int[] vTexWidth = { 0, 0, 0 }; // per plane + protected int texWidth, texHeight; // overall (stuffing planes in one texture) + protected ByteBuffer texCopy; + + public FFMPEGMediaPlayer() { + super(TextureType.GL, false); + if(!available) { + throw new RuntimeException("FFMPEGMediaPlayer not available"); + } + setTextureCount(1); + moviePtr = createInstance0(true); + if(0==moviePtr) { + throw new GLException("Couldn't create FFMPEGInstance"); + } + psm = new GLPixelStorageModes(); + } + + @Override + protected TextureSequence.TextureFrame createTexImage(GL gl, int idx, int[] tex) { + if(TextureType.GL == texType) { + final Texture texture = super.createTexImageImpl(gl, idx, tex, texWidth, texHeight, true); + lastTex = new EGLTextureFrame(null, texture, 0, 0); + } else { + throw new InternalError("n/a"); + } + return lastTex; + } + + @Override + protected void destroyTexImage(GL gl, TextureSequence.TextureFrame imgTex) { + lastTex = null; + super.destroyTexImage(gl, imgTex); + } + + @Override + protected void destroyImpl(GL gl) { + if (moviePtr != 0) { + destroyInstance0(moviePtr); + moviePtr = 0; + } + } + + @Override + protected void initGLStreamImpl(GL gl, int[] texNames) throws IOException { + if(0==moviePtr) { + throw new GLException("FFMPEG native instance null"); + } + final String urlS=urlConn.getURL().toExternalForm(); + + System.out.println("setURL: p1 "+this); + setStream0(moviePtr, urlS, -1, -1); + System.out.println("setURL: p2 "+this); + int tf; + switch(vBytesPerPixelPerPlane) { + case 1: tf = GL2ES2.GL_RED; break; + case 3: tf = GL2ES2.GL_RGB; break; + case 4: tf = GL2ES2.GL_RGBA; break; + default: throw new RuntimeException("Unsupported bytes-per-pixel / plane "+vBytesPerPixelPerPlane); + } + setTextureFormat(tf); + setTextureType(GL.GL_UNSIGNED_BYTE); + GLContextImpl ctx = (GLContextImpl)gl.getContext(); + ProcAddressTable pt = ctx.getGLProcAddressTable(); + if(pt instanceof GLES2ProcAddressTable) { + procAddrGLTexSubImage2D = ((GLES2ProcAddressTable)pt)._addressof_glTexSubImage2D; + } else if(pt instanceof GLES1ProcAddressTable) { + procAddrGLTexSubImage2D = ((GLES1ProcAddressTable)pt)._addressof_glTexSubImage2D; + } else if(pt instanceof GL4bcProcAddressTable) { + procAddrGLTexSubImage2D = ((GL4bcProcAddressTable)pt)._addressof_glTexSubImage2D; + } else { + throw new InternalError("Unknown ProcAddressTable: "+pt.getClass().getName()+" of "+ctx.getClass().getName()); + } + } + private void updateAttributes2(int pixFmt, int planes, int bitsPerPixel, int bytesPerPixelPerPlane, + int lSz0, int lSz1, int lSz2, + int tWd0, int tWd1, int tWd2) { + vPixelFmt = PixelFormat.valueOf(pixFmt); + vPlanes = planes; + vBitsPerPixel = bitsPerPixel; + vBytesPerPixelPerPlane = bytesPerPixelPerPlane; + vLinesize[0] = lSz0; vLinesize[1] = lSz1; vLinesize[2] = lSz2; + vTexWidth[0] = tWd0; vTexWidth[1] = tWd1; vTexWidth[2] = tWd2; + + switch(vPixelFmt) { + case YUV420P: + // YUV420P: Adding U+V on right side of fixed height texture, + // since width is already aligned by decoder. + // Y=w*h, Y=w/2*h/2, U=w/2*h/2 + // w*h + 2 ( w/2 * h/2 ) + // w*h + w*h/2 + // 2*w/2 * h + texWidth = vTexWidth[0] + vTexWidth[1]; texHeight = height; + break; + // case PIX_FMT_YUYV422: + case RGB24: + case BGR24: + case ARGB: + case RGBA: + case ABGR: + case BGRA: + texWidth = vTexWidth[0]; texHeight = height; + break; + default: // FIXME: Add more planar formats ! + throw new RuntimeException("Unsupported pixelformat: "+vPixelFmt); + } + if(DEBUG) { + System.err.println("XXX0: fmt "+vPixelFmt+", planes "+vPlanes+", bpp "+vBitsPerPixel+"/"+vBytesPerPixelPerPlane); + for(int i=0; i<3; i++) { + System.err.println("XXX0 "+i+": "+vTexWidth[i]+"/"+vLinesize[i]); + } + System.err.println("XXX0 total tex "+texWidth+"x"+texHeight); + } + } + + /** + * {@inheritDoc} + * + * If this implementation generates a specialized shader, + * it allows the user to override the default function name <code>ffmpegTexture2D</code>. + * Otherwise the call is delegated to it's super class. + */ + @Override + public String getTextureLookupFunctionName(String desiredFuncName) throws IllegalStateException { + if(State.Uninitialized == state) { + throw new IllegalStateException("Instance not initialized: "+this); + } + if(PixelFormat.YUV420P == vPixelFmt) { + if(null != desiredFuncName && desiredFuncName.length()>0) { + textureLookupFunctionName = desiredFuncName; + } + return textureLookupFunctionName; + } + return super.getTextureLookupFunctionName(desiredFuncName); + } + private String textureLookupFunctionName = "ffmpegTexture2D"; + + /** + * {@inheritDoc} + * + * Depending on the pixelformat, a specific conversion shader is being created, + * e.g. YUV420P to RGB. Otherwise the call is delegated to it's super class. + */ + @Override + public String getTextureLookupFragmentShaderImpl() throws IllegalStateException { + if(State.Uninitialized == state) { + throw new IllegalStateException("Instance not initialized: "+this); + } + final float tc_w_1 = (float)getWidth() / (float)texWidth; + switch(vPixelFmt) { + case YUV420P: + return + "vec4 "+textureLookupFunctionName+"(in "+getTextureSampler2DType()+" image, in vec2 texCoord) {\n"+ + " vec2 u_off = vec2("+tc_w_1+", 0.0);\n"+ + " vec2 v_off = vec2("+tc_w_1+", 0.5);\n"+ + " vec2 tc_half = texCoord*0.5;\n"+ + " float y,u,v,r,g,b;\n"+ + " y = texture2D(image, texCoord).r;\n"+ + " u = texture2D(image, u_off+tc_half).r;\n"+ + " v = texture2D(image, v_off+tc_half).r;\n"+ + " y = 1.1643*(y-0.0625);\n"+ + " u = u-0.5;\n"+ + " v = v-0.5;\n"+ + " r = y+1.5958*v;\n"+ + " g = y-0.39173*u-0.81290*v;\n"+ + " b = y+2.017*u;\n"+ + " return vec4(r, g, b, 1);\n"+ + "}\n" + ; + default: // FIXME: Add more planar formats ! + return super.getTextureLookupFragmentShaderImpl(); + } + } + + @Override + protected synchronized int getCurrentPositionImpl() { + return 0!=moviePtr ? getVideoPTS0(moviePtr) : 0; + } + + @Override + protected synchronized boolean setPlaySpeedImpl(float rate) { + return true; + } + + @Override + public synchronized boolean startImpl() { + if(0==moviePtr) { + return false; + } + return true; + } + + /** @return time position after issuing the command */ + @Override + public synchronized boolean pauseImpl() { + if(0==moviePtr) { + return false; + } + return true; + } + + /** @return time position after issuing the command */ + @Override + public synchronized boolean stopImpl() { + if(0==moviePtr) { + return false; + } + return true; + } + + /** @return time position after issuing the command */ + @Override + protected synchronized int seekImpl(int msec) { + if(0==moviePtr) { + throw new GLException("FFMPEG native instance null"); + } + int pts0 = getVideoPTS0(moviePtr); + int pts1 = seek0(moviePtr, msec); + System.err.println("Seek: "+pts0+" -> "+msec+" : "+pts1); + return pts1; + } + + @Override + protected TextureSequence.TextureFrame getLastTextureImpl() { + return lastTex; + } + + private long lastVideoTime = 0; + private int lastVideoPTS = 0; + private static final int dt_d = 9; + + @Override + protected TextureSequence.TextureFrame getNextTextureImpl(GL gl, boolean blocking) { + if(0==moviePtr) { + throw new GLException("FFMPEG native instance null"); + } + if(null != lastTex) { + psm.setUnpackAlignment(gl, 1); // RGBA ? 4 : 1 + try { + final Texture tex = lastTex.getTexture(); + gl.glActiveTexture(GL.GL_TEXTURE0+getTextureUnit()); + tex.enable(gl); + tex.bind(gl); + readNextPacket0(moviePtr, procAddrGLTexSubImage2D, textureTarget, textureFormat, textureType); + } finally { + psm.restore(gl); + } + final int pts = getVideoPTS0(moviePtr); // this frame + if(blocking) { + // poor mans video sync .. TODO: off thread 'readNextPackage0(..)' on shared GLContext and multi textures/unit! + final long now = System.currentTimeMillis(); + final long now_d = now - lastVideoTime; + final long pts_d = pts - lastVideoPTS; + final long dt = (long) ( (float) ( pts_d - now_d ) / getPlaySpeed() ) ; + lastVideoTime = now; + // System.err.println("s: pts-v "+pts+", pts-d "+pts_d+", now_d "+now_d+", dt "+dt); + if(dt>dt_d) { + try { + Thread.sleep(dt-dt_d); + } catch (InterruptedException e) { } + } /* else if(0>pts_d) { + System.err.println("s: pts-v "+pts+", pts-d "+pts_d+", now_d "+now_d+", dt "+dt); + } */ + } + lastVideoPTS = pts; + } + return lastTex; + } + + private void consumeAudio(int len) { + + } + + private static native int getAvUtilVersion0(); + private static native int getAvFormatVersion0(); + private static native int getAvCodecVersion0(); + private static native boolean initIDs0(); + private native long createInstance0(boolean verbose); + private native void destroyInstance0(long moviePtr); + + private native void setStream0(long moviePtr, String url, int vid, int aid); + + private native int getVideoPTS0(long moviePtr); + + private native int getAudioPTS0(long moviePtr); + private native Buffer getAudioBuffer0(long moviePtr, int plane); + + private native int readNextPacket0(long moviePtr, long procAddrGLTexSubImage2D, int texTarget, int texFmt, int texType); + + private native int seek0(long moviePtr, int position); + + public static enum PixelFormat { + // NONE= -1, + YUV420P, ///< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples) + YUYV422, ///< packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr + RGB24, ///< packed RGB 8:8:8, 24bpp, RGBRGB... + BGR24, ///< packed RGB 8:8:8, 24bpp, BGRBGR... + YUV422P, ///< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples) + YUV444P, ///< planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples) + YUV410P, ///< planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples) + YUV411P, ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) + GRAY8, ///< Y , 8bpp + MONOWHITE, ///< Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb + MONOBLACK, ///< Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb + PAL8, ///< 8 bit with RGB32 palette + YUVJ420P, ///< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of YUV420P and setting color_range + YUVJ422P, ///< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of YUV422P and setting color_range + YUVJ444P, ///< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of YUV444P and setting color_range + XVMC_MPEG2_MC,///< XVideo Motion Acceleration via common packet passing + XVMC_MPEG2_IDCT, + UYVY422, ///< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1 + UYYVYY411, ///< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3 + BGR8, ///< packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb) + BGR4, ///< packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits + BGR4_BYTE, ///< packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb) + RGB8, ///< packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb) + RGB4, ///< packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits + RGB4_BYTE, ///< packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb) + NV12, ///< planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V) + NV21, ///< as above, but U and V bytes are swapped + + ARGB, ///< packed ARGB 8:8:8:8, 32bpp, ARGBARGB... + RGBA, ///< packed RGBA 8:8:8:8, 32bpp, RGBARGBA... + ABGR, ///< packed ABGR 8:8:8:8, 32bpp, ABGRABGR... + BGRA, ///< packed BGRA 8:8:8:8, 32bpp, BGRABGRA... + + GRAY16BE, ///< Y , 16bpp, big-endian + GRAY16LE, ///< Y , 16bpp, little-endian + YUV440P, ///< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples) + YUVJ440P, ///< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of YUV440P and setting color_range + YUVA420P, ///< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples) + VDPAU_H264,///< H.264 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + VDPAU_MPEG1,///< MPEG-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + VDPAU_MPEG2,///< MPEG-2 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + VDPAU_WMV3,///< WMV3 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + VDPAU_VC1, ///< VC-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + RGB48BE, ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian + RGB48LE, ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as little-endian + + RGB565BE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian + RGB565LE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian + RGB555BE, ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), big-endian, most significant bit to 0 + RGB555LE, ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), little-endian, most significant bit to 0 + + BGR565BE, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian + BGR565LE, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian + BGR555BE, ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), big-endian, most significant bit to 1 + BGR555LE, ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), little-endian, most significant bit to 1 + + VAAPI_MOCO, ///< HW acceleration through VA API at motion compensation entry-point, Picture.data[3] contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers + VAAPI_IDCT, ///< HW acceleration through VA API at IDCT entry-point, Picture.data[3] contains a vaapi_render_state struct which contains fields extracted from headers + VAAPI_VLD, ///< HW decoding through VA API, Picture.data[3] contains a vaapi_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + + YUV420P16LE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian + YUV420P16BE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian + YUV422P16LE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + YUV422P16BE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian + YUV444P16LE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian + YUV444P16BE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian + VDPAU_MPEG4, ///< MPEG4 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + DXVA2_VLD, ///< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer + + RGB444LE, ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), little-endian, most significant bits to 0 + RGB444BE, ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), big-endian, most significant bits to 0 + BGR444LE, ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), little-endian, most significant bits to 1 + BGR444BE, ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), big-endian, most significant bits to 1 + Y400A, ///< 8bit gray, 8bit alpha + BGR48BE, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian + BGR48LE, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as little-endian + YUV420P9BE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian + YUV420P9LE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian + YUV420P10BE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian + YUV420P10LE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian + YUV422P10BE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian + YUV422P10LE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + YUV444P9BE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian + YUV444P9LE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian + YUV444P10BE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian + YUV444P10LE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian + YUV422P9BE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian + YUV422P9LE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + VDA_VLD, ///< hardware decoding through VDA + GBRP, ///< planar GBR 4:4:4 24bpp + GBRP9BE, ///< planar GBR 4:4:4 27bpp, big endian + GBRP9LE, ///< planar GBR 4:4:4 27bpp, little endian + GBRP10BE, ///< planar GBR 4:4:4 30bpp, big endian + GBRP10LE, ///< planar GBR 4:4:4 30bpp, little endian + GBRP16BE, ///< planar GBR 4:4:4 48bpp, big endian + GBRP16LE, ///< planar GBR 4:4:4 48bpp, little endian + COUNT ///< number of pixel formats in this list + ; + public static PixelFormat valueOf(int i) { + for (PixelFormat fmt : PixelFormat.values()) { + if(fmt.ordinal() == i) { + return fmt; + } + } + return null; + } + } + +} + |