示例#1
0
        public virtual int sceMpegBaseYCrCbCopyVme(TPointer destBufferYCrCb, TPointer32 srcBufferYCrCb, int type)
        {
            SceMpegYCrCbBuffer destMpegYCrCbBuffer = new SceMpegYCrCbBuffer();

            destMpegYCrCbBuffer.read(destBufferYCrCb);

            SceMpegYCrCbBufferSrc srcMpegYCrCbBuffer = new SceMpegYCrCbBufferSrc();

            srcMpegYCrCbBuffer.read(srcBufferYCrCb);

            //if (log.DebugEnabled)
            {
                Console.WriteLine(string.Format("sceMpegBaseYCrCbCopyVme destMpegYCrCbBuffer: {0}", destMpegYCrCbBuffer));
                Console.WriteLine(string.Format("sceMpegBaseYCrCbCopyVme srcMpegYCrCbBuffer: {0}", srcMpegYCrCbBuffer));
            }

            Memory mem      = destBufferYCrCb.Memory;
            int    sizeY    = srcMpegYCrCbBuffer.frameWidth * srcMpegYCrCbBuffer.frameHeight;
            int    sizeCrCb = sizeY >> 2;

            copy(mem, destMpegYCrCbBuffer.bufferY, srcMpegYCrCbBuffer.bufferY, sizeY);
            copy(mem, destMpegYCrCbBuffer.bufferY2, srcMpegYCrCbBuffer.bufferY2, sizeY);
            copy(mem, destMpegYCrCbBuffer.bufferCr, srcMpegYCrCbBuffer.bufferCr, sizeCrCb);
            copy(mem, destMpegYCrCbBuffer.bufferCb, srcMpegYCrCbBuffer.bufferCb, sizeCrCb);
            copy(mem, destMpegYCrCbBuffer.bufferCr2, srcMpegYCrCbBuffer.bufferCr2, sizeCrCb);
            copy(mem, destMpegYCrCbBuffer.bufferCb2, srcMpegYCrCbBuffer.bufferCb2, sizeCrCb);

            return(0);
        }
示例#2
0
        public virtual int sceMpegBaseCscVme(TPointer bufferRGB, TPointer bufferRGB2, int bufferWidth, TPointer32 bufferYCrCb)
        {
            SceMpegYCrCbBuffer sceMpegYCrCbBuffer = new SceMpegYCrCbBuffer();

            sceMpegYCrCbBuffer.read(bufferYCrCb);

            int width  = sceMpegYCrCbBuffer.frameBufferWidth16 << 4;
            int height = sceMpegYCrCbBuffer.frameBufferHeight16 << 4;

            int videoPixelMode = TPSM_PIXEL_STORAGE_MODE_32BIT_ABGR8888;
            int bytesPerPixel  = sceDisplay.getPixelFormatBytes(videoPixelMode);
            int rangeX         = 0;
            int rangeY         = 0;
            int rangeWidth     = width;
            int rangeHeight    = height;
            int destAddr       = bufferRGB.Address;

            //if (log.DebugEnabled)
            {
                Console.WriteLine(string.Format("sceMpegBaseCscVme sceMpegYCrCbBuffer: {0}", sceMpegYCrCbBuffer));
            }

            int width2  = width >> 1;
            int height2 = height >> 1;
            int Length  = width * height;
            int length2 = width2 * height2;

            // Read the YCbCr image
            int[] luma = getIntBuffer(Length);
            int[] cb   = getIntBuffer(length2);
            int[] cr   = getIntBuffer(length2);
            read(sceMpegYCrCbBuffer.bufferY, Length, luma, 0);
            read(sceMpegYCrCbBuffer.bufferCb, length2, cb, 0);
            read(sceMpegYCrCbBuffer.bufferCr, length2, cr, 0);

            // Convert YCbCr to ABGR
            int[] abgr = getIntBuffer(Length);
            H264Utils.YUV2ABGR(width, height, luma, cb, cr, abgr);

            releaseIntBuffer(luma);
            releaseIntBuffer(cb);
            releaseIntBuffer(cr);

            // Do not cache the video image as a texture in the VideoEngine to allow fluid rendering
            VideoEngine.Instance.addVideoTexture(destAddr, destAddr + (rangeY + rangeHeight) * bufferWidth * bytesPerPixel);

            // Write the ABGR image
            if (videoPixelMode == TPSM_PIXEL_STORAGE_MODE_32BIT_ABGR8888 && RuntimeContext.hasMemoryInt())
            {
                // Optimize the most common case
                int pixelIndex = rangeY * width + rangeX;
                for (int i = 0; i < rangeHeight; i++)
                {
                    int addr = destAddr + (i * bufferWidth) * bytesPerPixel;
                    Array.Copy(abgr, pixelIndex, RuntimeContext.MemoryInt, addr >> 2, rangeWidth);
                    pixelIndex += width;
                }
            }
            else
            {
                int addr = destAddr;
                for (int i = 0; i < rangeHeight; i++)
                {
                    IMemoryWriter memoryWriter = MemoryWriter.getMemoryWriter(addr, rangeWidth * bytesPerPixel, bytesPerPixel);
                    int           pixelIndex   = (i + rangeY) * width + rangeX;
                    for (int j = 0; j < rangeWidth; j++, pixelIndex++)
                    {
                        int abgr8888   = abgr[pixelIndex];
                        int pixelColor = Debug.getPixelColor(abgr8888, videoPixelMode);
                        memoryWriter.writeNext(pixelColor);
                    }
                    memoryWriter.flush();
                    addr += bufferWidth * bytesPerPixel;
                }
            }
            releaseIntBuffer(abgr);

            return(0);
        }