JNIEXPORT jboolean JNICALL Java_org_wysaid_nativePort_CGEFFmpegNativeLibrary_nativeGenerateVideoWithFilter(JNIEnv *env, jclass cls, jstring outputFilename, jstring inputFilename, jstring filterConfig, jfloat filterIntensity, jobject blendImage, jint blendMode, jfloat blendIntensity, jboolean mute)
    {
        CGE_LOG_INFO("##### nativeGenerateVideoWithFilter!!!");
        
        if(outputFilename == nullptr || inputFilename == nullptr)
            return false;
        
        CGESharedGLContext* glContext = CGESharedGLContext::create(2048, 2048); //Max video resolution size of 2k.
        
        if(glContext == nullptr)
        {
            CGE_LOG_ERROR("Create GL Context Failed!");
            return false;
        }
        
        glContext->makecurrent();
        
        CGETextureResult texResult = {0};
        
        jclass nativeLibraryClass = env->FindClass("org/wysaid/nativePort/CGENativeLibrary");
        
        if(blendImage != nullptr)
            texResult = cgeLoadTexFromBitmap_JNI(env, nativeLibraryClass, blendImage);
        
        const char* outFilenameStr = env->GetStringUTFChars(outputFilename, 0);
        const char* inFilenameStr = env->GetStringUTFChars(inputFilename, 0);
        const char* configStr = filterConfig == nullptr ? nullptr : env->GetStringUTFChars(filterConfig, 0);

        CGETexLoadArg texLoadArg;
        texLoadArg.env = env;
        texLoadArg.cls = env->FindClass("org/wysaid/nativePort/CGENativeLibrary");
        
        bool retStatus = CGE::cgeGenerateVideoWithFilter(outFilenameStr, inFilenameStr, configStr, filterIntensity, texResult.texID, (CGETextureBlendMode)blendMode, blendIntensity, mute, &texLoadArg);
        
        env->ReleaseStringUTFChars(outputFilename, outFilenameStr);
        env->ReleaseStringUTFChars(inputFilename, inFilenameStr);
        
        if(configStr != nullptr)
            env->ReleaseStringUTFChars(filterConfig, configStr);
        
        CGE_LOG_INFO("generate over!\n");
        
        delete glContext;
        
        return retStatus;
    }
Пример #2
0
    jobject cgeFilterImage_CustomFilters(JNIEnv *env, jobject bmp, CustomFilterType type, float intensity, jboolean hasContext)
    {
        if(type < 0 || type >= CGE_CUSTOM_FILTER_TOTAL_NUMBER || intensity == 0.0f || bmp == nullptr)
            return bmp;
        
        CGESharedGLContext* ctx = nullptr;
        jobject newBitmap = nullptr;
        
        if(!hasContext)
        {
            ctx = CGESharedGLContext::create();

            if(ctx == nullptr)
            {
                CGE_LOG_ERROR("create context failed!");
                return nullptr;
            }

            ctx->makecurrent();
        }
        
        //similar with cgeNativeLibrary.cpp
        {
            AndroidBitmapInfo info;
            int w, h, ret;
            char* row;

            CGE_LOG_CODE(clock_t tm = clock();)

            if ((ret = AndroidBitmap_getInfo(env, bmp, &info)) < 0)
            {
                CGE_LOG_ERROR("AndroidBitmap_getInfo() failed ! error=%d", ret);
                return nullptr;
            }
            CGE_LOG_INFO("color image :: width is %d; height is %d; stride is %d; format is %d;flags is %d", info.width, info.height, info.stride, info.format, info.flags);
            if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888)
            {
                CGE_LOG_ERROR("Bitmap format is not RGBA_8888 !");
                return nullptr;
            }

            // get the basic information of the image
            w = info.width;
            h = info.height;

            jclass bitmapCls = env->GetObjectClass(bmp);

            ret = AndroidBitmap_lockPixels(env, bmp, (void**) &row);
            if (ret < 0)
            {
                CGE_LOG_ERROR("AndroidBitmap_lockPixels() failed ! error=%d", ret);
                return nullptr;
            }

            CGEImageHandler handler;
            handler.initWithRawBufferData(row, w, h, CGE_FORMAT_RGBA_INT8, false);
            AndroidBitmap_unlockPixels(env, bmp);

            CGEImageFilterInterface* customFilter = cgeCreateCustomFilterByType(type);

            if(customFilter == nullptr)
            {
                CGE_LOG_ERROR("create Custom filter failed!");;
                return nullptr;
            }
            
            auto* filter = new CGEMutipleEffectFilter();
            filter->setTextureLoadFunction(cgeGlobalTextureLoadFunc, nullptr);
            filter->initCustomize();
            filter->addFilter(customFilter);
            filter->setIntensity(intensity);

            handler.addImageFilter(filter);
            handler.processingFilters();

            jmethodID createBitmapFunction = env->GetStaticMethodID(bitmapCls, "createBitmap", "(IILandroid/graphics/Bitmap$Config;)Landroid/graphics/Bitmap;");
            jstring configName = env->NewStringUTF("ARGB_8888");
            jclass bitmapConfigClass = env->FindClass("android/graphics/Bitmap$Config");
            jmethodID valueOfBitmapConfigFunction = env->GetStaticMethodID(bitmapConfigClass, "valueOf", "(Ljava/lang/String;)Landroid/graphics/Bitmap$Config;");
            jobject bitmapConfig = env->CallStaticObjectMethod(bitmapConfigClass, valueOfBitmapConfigFunction, configName);
            env->DeleteLocalRef(configName);
            newBitmap = env->CallStaticObjectMethod(bitmapCls, createBitmapFunction, info.width, info.height, bitmapConfig);

            ret = AndroidBitmap_lockPixels(env, newBitmap, (void**) &row);
            if (ret < 0)
            {
                CGE_LOG_ERROR("AndroidBitmap_lockPixels() failed ! error=%d", ret);
                // AndroidBitmap_unlockPixels(env, bmp);
                return nullptr;
            }

            handler.getOutputBufferData(row, CGE_FORMAT_RGBA_INT8);
            AndroidBitmap_unlockPixels(env, newBitmap);
        }