Esempio n. 1
0
void Java_com_richitec_imeeting_video_ECVideoEncoder_setupVideoEncoder(
		JNIEnv* env, jobject thiz) {
	qvo = (QuickVideoOutput*) malloc(sizeof(QuickVideoOutput));
	qvo->width = out_img_width;
	qvo->height = out_img_height;

	char rtmp_full_path[300];
	memset(rtmp_full_path, 0, sizeof rtmp_full_path);
	sprintf(rtmp_full_path, "%s/%s/%s live=1 conn=S:%s", rtmp_url, group_id,
			live_name, live_name);
	D("rtmp full path: %s", rtmp_full_path);

	int ret = init_quick_video_output(qvo, rtmp_full_path, "flv");
	if (ret < 0) {
		D("quick video output initial failed.");
		release_video_encoder();
		call_void_method(env, thiz, "onVideoLiveCannotEstablish");
		return;
	}

	enum PixelFormat dst_pix_fmt = qvo->video_stream->codec->pix_fmt;
	src_pix_fmt = PIX_FMT_NV21;

	raw_picture = alloc_picture(dst_pix_fmt, qvo->width, qvo->height);
	tmp_picture = avcodec_alloc_frame();
	raw_picture->pts = 0;

	is_video_encode_ready = 1;
	D("video encoder setup ok");
	call_void_method(env, thiz, "onVideoLiveEstablish");
}
Esempio n. 2
0
void Java_com_richitec_imeeting_video_ECVideoEncoder_processRawFrame(
		JNIEnv* env, jobject thiz, jbyteArray buffer, jint width, jint height,
		jint rotateDegree) {
	if (!qvo || !is_video_encode_ready) {
		return;
	}
//	D("process raw frame - width: %d height: %d", width, height);

	jint rotateWidth, rotateHeight;

	AVCodecContext *c = qvo->video_stream->codec;

	jbyte *p_buffer_array = (*env)->GetByteArrayElements(env, buffer, 0);

//	D("process raw frame - rotate degree: %d", rotateDegree);

	unsigned char * p_rotated_buffer = rotateYUV420SP(p_buffer_array, width,
			height, rotateDegree, &rotateWidth, &rotateHeight);
	if (!p_rotated_buffer) {
		(*env)->ReleaseByteArrayElements(env, buffer, p_buffer_array,
				JNI_ABORT);
		return;
	}

	avpicture_fill((AVPicture *) tmp_picture, p_rotated_buffer, src_pix_fmt,
			rotateWidth, rotateHeight);
//	D("avpicture fill ok");
	(*env)->ReleaseByteArrayElements(env, buffer, p_buffer_array, JNI_ABORT);

	img_convert_ctx = sws_getCachedContext(img_convert_ctx, rotateWidth,
			rotateHeight, src_pix_fmt, qvo->width, qvo->height, c->pix_fmt,
			SWS_BILINEAR, NULL, NULL, NULL);
	sws_scale(img_convert_ctx, tmp_picture->data, tmp_picture->linesize, 0,
			rotateHeight, raw_picture->data, raw_picture->linesize);

	int out_size = write_video_frame(qvo, raw_picture);

//	D(
//			"stream pts val: %lld time base: %d / %d", qvo->video_stream->pts.val, qvo->video_stream->time_base.num, qvo->video_stream->time_base.den);
//	double video_pts = (double) qvo->video_stream->pts.val
//			* qvo->video_stream->time_base.num
//			/ qvo->video_stream->time_base.den;
//	D("write video frame - size: %d video pts: %f", out_size, video_pts);

	raw_picture->pts++;

	free(p_rotated_buffer);

	if (out_size == -2) {
		// network interrupted
		call_void_method(env, thiz, "onVideoLiveDisconnected");
	}
}
Esempio n. 3
0
jobject mesh_material(JNIEnv *env, const aiScene *assimp_scene, int index) {
    aiMesh* assimp_mesh = assimp_scene->mMeshes[index];
    aiMaterial* assimp_material =
            assimp_scene->mMaterials[assimp_mesh->mMaterialIndex];
    jobject jassimp_material = NULL;

    if (!create_instance(env, "org/gearvrf/jassimp/AiMaterial",
            jassimp_material)) {
        return NULL;
    }

    /* set texture numbers */
    for (int texture_type_index = aiTextureType_DIFFUSE;
            texture_type_index < aiTextureType_UNKNOWN; texture_type_index++) {
        aiTextureType texture_type =
                static_cast<aiTextureType>(texture_type_index);

        unsigned int total_textures = assimp_material->GetTextureCount(
                texture_type);
        jvalue set_number_params[2];
        set_number_params[0].i = texture_type_index;
        set_number_params[1].i = total_textures;

        if (!call_void_method(env, jassimp_material,
                "org/gearvrf/jassimp/AiMaterial", "setTextureNumber", "(II)V",
                set_number_params)) {
            return NULL;
        }
    }

    for (unsigned int p = 0; p < assimp_material->mNumProperties; p++) {
        const aiMaterialProperty* assimp_material_property =
                assimp_material->mProperties[p];
        jobject jassimp_material_property = NULL;
        jvalue constructor_params[5];
        constructor_params[0].l = env->NewStringUTF(
                assimp_material_property->mKey.C_Str());
        constructor_params[1].i = assimp_material_property->mSemantic;
        constructor_params[2].i = assimp_material_property->mIndex;
        constructor_params[3].i = assimp_material_property->mType;

        /* special case conversion for color3 */
        if (NULL != strstr(assimp_material_property->mKey.C_Str(), "clr")
                && assimp_material_property->mType == aiPTI_Float
                && assimp_material_property->mDataLength == 3 * sizeof(float)) {
            jobject jassimp_data = NULL;

            /* wrap color */
            jvalue wrap_color_params[3];
            wrap_color_params[0].f =
                    ((float*) assimp_material_property->mData)[0];
            wrap_color_params[1].f =
                    ((float*) assimp_material_property->mData)[1];
            wrap_color_params[2].f =
                    ((float*) assimp_material_property->mData)[2];
            if (!call_static_object(env, "org/gearvrf/jassimp/Jassimp",
                    "wrapColor3", "(FFF)Ljava/lang/Object;", wrap_color_params,
                    jassimp_data)) {
                return NULL;
            }

            constructor_params[4].l = jassimp_data;
            if (!create_instance(env, "org/gearvrf/jassimp/AiMaterial$Property",
                    "(Ljava/lang/String;IIILjava/lang/Object;)V",
                    constructor_params, jassimp_material_property)) {
                return NULL;
            }
        }
        /* special case conversion for color4 */
        else if (NULL != strstr(assimp_material_property->mKey.C_Str(), "clr")
                && assimp_material_property->mType == aiPTI_Float
                && assimp_material_property->mDataLength == 4 * sizeof(float)) {
            jobject jassimp_data = NULL;

            /* wrap color */
            jvalue wrap_color_params[4];
            wrap_color_params[0].f =
                    ((float*) assimp_material_property->mData)[0];
            wrap_color_params[1].f =
                    ((float*) assimp_material_property->mData)[1];
            wrap_color_params[2].f =
                    ((float*) assimp_material_property->mData)[2];
            wrap_color_params[3].f =
                    ((float*) assimp_material_property->mData)[3];
            if (!call_static_object(env, "org/gearvrf/jassimp/Jassimp",
                    "wrapColor4", "(FFFF)Ljava/lang/Object;", wrap_color_params,
                    jassimp_data)) {
                return NULL;
            }

            constructor_params[4].l = jassimp_data;
            if (!create_instance(env, "org/gearvrf/jassimp/AiMaterial$Property",
                    "(Ljava/lang/String;IIILjava/lang/Object;)V",
                    constructor_params, jassimp_material_property)) {
                return NULL;
            }
        } else if (assimp_material_property->mType == aiPTI_Float
                && assimp_material_property->mDataLength == sizeof(float)) {
            jobject jassimp_data = NULL;

            jvalue new_float_params[1];
            new_float_params[0].f =
                    ((float*) assimp_material_property->mData)[0];
            if (!create_instance(env, "java/lang/Float", "(F)V",
                    new_float_params, jassimp_data)) {
                return NULL;
            }

            constructor_params[4].l = jassimp_data;
            if (!create_instance(env, "org/gearvrf/jassimp/AiMaterial$Property",
                    "(Ljava/lang/String;IIILjava/lang/Object;)V",
                    constructor_params, jassimp_material_property)) {
                return NULL;
            }
        } else if (assimp_material_property->mType == aiPTI_Integer
                && assimp_material_property->mDataLength == sizeof(int)) {
            jobject jassimp_data = NULL;

            jvalue new_int_params[1];
            new_int_params[0].i = ((int*) assimp_material_property->mData)[0];
            if (!create_instance(env, "java/lang/Integer", "(I)V",
                    new_int_params, jassimp_data)) {
                return NULL;
            }

            constructor_params[4].l = jassimp_data;
            if (!create_instance(env, "org/gearvrf/jassimp/AiMaterial$Property",
                    "(Ljava/lang/String;IIILjava/lang/Object;)V",
                    constructor_params, jassimp_material_property)) {
                return NULL;
            }
        } else if (assimp_material_property->mType == aiPTI_String) {
            /* skip length prefix */
            jobject jassimp_data = env->NewStringUTF(
                    assimp_material_property->mData + 4);

            constructor_params[4].l = jassimp_data;
            if (!create_instance(env, "org/gearvrf/jassimp/AiMaterial$Property",
                    "(Ljava/lang/String;IIILjava/lang/Object;)V",
                    constructor_params, jassimp_material_property)) {
                return NULL;
            }
        } else {
            constructor_params[4].i = assimp_material_property->mDataLength;

            /* generic copy code, uses dump ByteBuffer on java side */
            if (!create_instance(env, "org/gearvrf/jassimp/AiMaterial$Property",
                    "(Ljava/lang/String;IIII)V", constructor_params,
                    jassimp_material_property)) {
                return NULL;
            }

            jobject jassimp_buffer = NULL;

            if (!get_field(env, jassimp_material_property, "m_data",
                    "Ljava/lang/Object;", jassimp_buffer)) {
                return NULL;
            }

            if (env->GetDirectBufferCapacity(jassimp_buffer)
                    != assimp_material_property->mDataLength) {
                LOGE("invalid direct buffer\n");
                return NULL;
            }

            void* jassimp_buffer_ptr = env->GetDirectBufferAddress(
                    jassimp_buffer);

            if (NULL == jassimp_buffer_ptr) {
                LOGE("could not access direct buffer\n");
                return NULL;
            }

            memcpy(jassimp_buffer_ptr, assimp_material_property->mData,
                    assimp_material_property->mDataLength);
        }

        /* add property */
        jobject jassimp_properties = NULL;

        if (!get_field(env, jassimp_material, "m_properties",
                "Ljava/util/List;", jassimp_properties)) {
            return NULL;
        }

        jvalue add_properties_params[1];
        add_properties_params[0].l = jassimp_material_property;
        if (!call_method(env, jassimp_properties, "java/util/Collection", "add",
                "(Ljava/lang/Object;)Z", add_properties_params)) {
            return NULL;
        }
    }
    return jassimp_material;
}