录屏android实时展示,Android c++屏幕实时录制

最新推荐文章于 2024-05-13 02:34:46 发布
最新推荐文章于 2024-05-13 02:34:46 发布
阅读量821 收藏 1
点赞数
文章标签： 录屏android实时展示

功能:沿用Android cmds下的screenrecord代码，整理成可以供native程序调用的一个可以获取实时screen h264码流的一个库，分享一下！！

f48057579334e9ef0f805214bf6a7e34.png

头文件screenrecord.h#include 

class IScreenRecordCallback

{

public:

virtual ~IScreenRecordCallback(){}

virtual void onData(void* pData, size_t size) = 0;

//virtual void onCodecConfig(void* pData, size_t size) = 0;

};

class ScreenRecordImp;

class ScreenRecord

{

public:

ScreenRecord();

~ScreenRecord();

int start(IScreenRecordCallback* callback);

void stop();

private:

ScreenRecordImp* m_pImp;

};

实现文件:screenrecord.cpp#include "screenrecord.h"

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

using namespace android;

using namespace std;

#define LOG_TAG "LibScreenRecord"

//#define LOG_NDEBUG 0

static const uint32_t kFallbackWidth = 1280;        // 720p

static const uint32_t kFallbackHeight = 720;

class ScreenRecordImp

{

public:

ScreenRecordImp();

int start(IScreenRecordCallback* callback);

void stop();

private:

bool isDeviceRotated(int orientation);

status_t prepareEncoder(float displayFps, sp* pCodec,

sp* pBufferProducer);

status_t prepareVirtualDisplay(const DisplayInfo& mainDpyInfo,

const sp& bufferProducer,

sp* pDisplayHandle);

status_t setDisplayProjection(const sp& dpy,

const DisplayInfo& mainDpyInfo);

status_t runEncoder(const sp& encoder, IScreenRecordCallback* callback, sp& mainDpy, sp& dpy, uint8_t orientation);

private:

bool mRotate;                // rotate 90 degrees

//bool mSizeSpecified;         // was size explicitly requested?

uint32_t mVideoWidth;            // default width+height

uint32_t mVideoHeight;

uint32_t mBitRate;

//uint32_t mTimeLimitSec;

bool mStopRequested;

};

ScreenRecord::ScreenRecord()

{

m_pImp = new ScreenRecordImp;

}

ScreenRecord::~ScreenRecord()

{

stop();

delete m_pImp;

m_pImp = NULL;

}

int ScreenRecord::start(IScreenRecordCallback* callback)

{

return m_pImp->start(callback);

}

void ScreenRecord::stop()

{

m_pImp->stop();

}

ScreenRecordImp::ScreenRecordImp():mRotate(false),

mVideoWidth(0),

mVideoHeight(0),

mBitRate(4000000),         // 4Mbp

mStopRequested(true)

{

}

bool ScreenRecordImp::isDeviceRotated(int orientation) {

return orientation != DISPLAY_ORIENTATION_0 &&

orientation != DISPLAY_ORIENTATION_180;

}

status_t ScreenRecordImp::setDisplayProjection(const sp& dpy,

const DisplayInfo& mainDpyInfo) {

status_t err;

// Set the region of the layer stack we're interested in, which in our

// case is "all of it".  If the app is rotated (so that the width of the

// app is based on the height of the display), reverse width/height.

bool deviceRotated = isDeviceRotated(mainDpyInfo.orientation);

uint32_t sourceWidth, sourceHeight;

if (!deviceRotated) {

sourceWidth = mainDpyInfo.w;

sourceHeight = mainDpyInfo.h;

} else {

ALOGV("using rotated width/height");

sourceHeight = mainDpyInfo.w;

sourceWidth = mainDpyInfo.h;

}

Rect layerStackRect(sourceWidth, sourceHeight);

// We need to preserve the aspect ratio of the display.

float displayAspect = (float) sourceHeight / (float) sourceWidth;

// Set the way we map the output onto the display surface (which will

// be e.g. 1280x720 for a 720p video).  The rect is interpreted

// post-rotation, so if the display is rotated 90 degrees we need to

// "pre-rotate" it by flipping width/height, so that the orientation

// adjustment changes it back.

//

// We might want to encode a portrait display as landscape to use more

// of the screen real estate.  (If players respect a 90-degree rotation

// hint, we can essentially get a 720x1280 video instead of 1280x720.)

// In that case, we swap the configured video width/height and then

// supply a rotation value to the display projection.

uint32_t videoWidth, videoHeight;

uint32_t outWidth, outHeight;

if (!mRotate) {

videoWidth = mVideoWidth;

videoHeight = mVideoHeight;

} else {

videoWidth = mVideoHeight;

videoHeight = mVideoWidth;

}

if (videoHeight > (uint32_t)(videoWidth * displayAspect)) {

// limited by narrow width; reduce height

outWidth = videoWidth;

outHeight = (uint32_t)(videoWidth * displayAspect);

} else {

// limited by short height; restrict width

outHeight = videoHeight;

outWidth = (uint32_t)(videoHeight / displayAspect);

}

uint32_t offX, offY;

offX = (videoWidth - outWidth) / 2;

offY = (videoHeight - outHeight) / 2;

Rect displayRect(offX, offY, offX + outWidth, offY + outHeight);

/*if (gVerbose) {

if (mRotate) {

printf("Rotated content area is %ux%u at offset x=%d y=%d\n",

outHeight, outWidth, offY, offX);

} else {

printf("Content area is %ux%u at offset x=%d y=%d\n",

outWidth, outHeight, offX, offY);

}

}*/

SurfaceComposerClient::setDisplayProjection(dpy,

mRotate ? DISPLAY_ORIENTATION_90 : DISPLAY_ORIENTATION_0,

layerStackRect, displayRect);

return NO_ERROR;

}

status_t ScreenRecordImp::prepareEncoder(float displayFps, sp* pCodec,

sp* pBufferProducer)

{

cout<

status_t err;

sp format = new AMessage;

format->setInt32("width", mVideoWidth);

format->setInt32("height", mVideoHeight);

format->setString("mime", "video/avc");

format->setInt32("color-format", OMX_COLOR_FormatAndroidOpaque);

format->setInt32("bitrate", mBitRate);

format->setFloat("frame-rate", displayFps);

format->setInt32("i-frame-interval", 10);

sp looper = new ALooper;

looper->setName("libscreenrecord_looper");

looper->start();

ALOGV("Creating codec");

cout<

sp codec = MediaCodec::CreateByType(looper, "video/avc", true);

if (codec == NULL) {

fprintf(stderr, "ERROR: unable to create video/avc codec instance\n");

return UNKNOWN_ERROR;

}

err = codec->configure(format, NULL, NULL,

MediaCodec::CONFIGURE_FLAG_ENCODE);

if (err != NO_ERROR) {

codec->release();

codec.clear();

fprintf(stderr, "ERROR: unable to configure codec (err=%d)\n", err);

return err;

}

ALOGV("Creating buffer producer");

cout<

sp bufferProducer;

err = codec->createInputSurface(&bufferProducer);

if (err != NO_ERROR) {

codec->release();

codec.clear();

fprintf(stderr,

"ERROR: unable to create encoder input surface (err=%d)\n", err);

return err;

}

ALOGV("Starting codec");

cout<

err = codec->start();

if (err != NO_ERROR) {

codec->release();

codec.clear();

fprintf(stderr, "ERROR: unable to start codec (err=%d)\n", err);

return err;

}

ALOGV("Codec prepared");

cout<

*pCodec = codec;

*pBufferProducer = bufferProducer;

return 0;

}

status_t ScreenRecordImp::prepareVirtualDisplay(const DisplayInfo& mainDpyInfo,

const sp& bufferProducer,

sp* pDisplayHandle) {

cout<

status_t err;

// Set the region of the layer stack we're interested in, which in our

// case is "all of it".  If the app is rotated (so that the width of the

// app is based on the height of the display), reverse width/height.

bool deviceRotated = isDeviceRotated(mainDpyInfo.orientation);

uint32_t sourceWidth, sourceHeight;

if (!deviceRotated) {

sourceWidth = mainDpyInfo.w;

sourceHeight = mainDpyInfo.h;

} else {

ALOGV("using rotated width/height");

sourceHeight = mainDpyInfo.w;

sourceWidth = mainDpyInfo.h;

}

Rect layerStackRect(sourceWidth, sourceHeight);

// We need to preserve the aspect ratio of the display.

float displayAspect = (float) sourceHeight / (float) sourceWidth;

// Set the way we map the output onto the display surface (which will

// be e.g. 1280x720 for a 720p video).  The rect is interpreted

// post-rotation, so if the display is rotated 90 degrees we need to

// "pre-rotate" it by flipping width/height, so that the orientation

// adjustment changes it back.

//

// We might want to encode a portrait display as landscape to use more

// of the screen real estate.  (If players respect a 90-degree rotation

// hint, we can essentially get a 720x1280 video instead of 1280x720.)

// In that case, we swap the configured video width/height and then

// supply a rotation value to the display projection.

uint32_t videoWidth, videoHeight;

uint32_t outWidth, outHeight;

if (!mRotate) {

videoWidth = mVideoWidth;

videoHeight = mVideoHeight;

} else {

videoWidth = mVideoHeight;

videoHeight = mVideoWidth;

}

if (videoHeight > (uint32_t)(videoWidth * displayAspect)) {

// limited by narrow width; reduce height

outWidth = videoWidth;

outHeight = (uint32_t)(videoWidth * displayAspect);

} else {

// limited by short height; restrict width

outHeight = videoHeight;

outWidth = (uint32_t)(videoHeight / displayAspect);

}

uint32_t offX, offY;

offX = (videoWidth - outWidth) / 2;

offY = (videoHeight - outHeight) / 2;

Rect displayRect(offX, offY, offX + outWidth, offY + outHeight);

cout<

sp dpy = SurfaceComposerClient::createDisplay(

String8("LibScreenRecorder"), false /* secure */);

SurfaceComposerClient::openGlobalTransaction();

SurfaceComposerClient::setDisplaySurface(dpy, bufferProducer);

SurfaceComposerClient::setDisplayProjection(dpy,

mRotate ? DISPLAY_ORIENTATION_90 : DISPLAY_ORIENTATION_0,

layerStackRect, displayRect);

SurfaceComposerClient::setDisplayLayerStack(dpy, 0);    // default stack

SurfaceComposerClient::closeGlobalTransaction();

*pDisplayHandle = dpy;

return NO_ERROR;

}

status_t ScreenRecordImp::runEncoder(const sp& encoder, IScreenRecordCallback* callback, sp& mainDpy, sp& virtualDpy,

uint8_t orientation)

{

cout<

static int kTimeout = 250000;   // be responsive on signal

status_t err;

ssize_t trackIdx = -1;

uint32_t debugNumFrames = 0;

int64_t startWhenNsec = systemTime(CLOCK_MONOTONIC);

//int64_t endWhenNsec = startWhenNsec + seconds_to_nanoseconds(180);

Vector > buffers;

err = encoder->getOutputBuffers(&buffers);

if (err != NO_ERROR) {

fprintf(stderr, "Unable to get output buffers (err=%d)\n", err);

return err;

}

DisplayInfo mainDpyInfo;

cout<

// This is set by the signal handler.

mStopRequested = false;

// Run until we're signaled.

while (!mStopRequested) {

size_t bufIndex, offset, size;

int64_t ptsUsec;

uint32_t flags;

/*if (systemTime(CLOCK_MONOTONIC) > endWhenNsec) {

break;

}*/

ALOGV("Calling dequeueOutputBuffer");

err = encoder->dequeueOutputBuffer(&bufIndex, &offset, &size, &ptsUsec,

&flags, kTimeout);

ALOGV("dequeueOutputBuffer returned %d", err);

cout<

switch (err) {

case NO_ERROR:

// got a buffer

if ((flags & MediaCodec::BUFFER_FLAG_CODECCONFIG) != 0)

{

// ignore this -- we passed the CSD into MediaMuxer when

// we got the format change notification

ALOGV("Got codec config buffer (%u bytes); ignoring", size);

cout<

//size = 0;

}

if (size != 0)

{

ALOGV("Got data in buffer %d, size=%d, pts=%lld",

bufIndex, size, ptsUsec);

//CHECK(trackIdx != -1);

// If the virtual display isn't providing us with timestamps,

// use the current time.

if (ptsUsec == 0) {

ptsUsec = systemTime(SYSTEM_TIME_MONOTONIC) / 1000;

}

// The MediaMuxer docs are unclear, but it appears that we

// need to pass either the full set of BufferInfo flags, or

// (flags & BUFFER_FLAG_SYNCFRAME).

/*err = muxer->writeSampleData(buffers[bufIndex], trackIdx,

ptsUsec, flags);

if (err != NO_ERROR) {

fprintf(stderr, "Failed writing data to muxer (err=%d)\n",

err);

return err;

}*/

{ // scope

//ATRACE_NAME("orientation");

// Check orientation, update if it has changed.

//

// Polling for changes is inefficient and wrong, but the

// useful stuff is hard to get at without a Dalvik VM.

err = SurfaceComposerClient::getDisplayInfo(mainDpy,

&mainDpyInfo);

if (err != NO_ERROR) {

ALOGW("getDisplayInfo(main) failed: %d", err);

} else if (orientation != mainDpyInfo.orientation) {

ALOGD("orientation changed, now %d", mainDpyInfo.orientation);

SurfaceComposerClient::openGlobalTransaction();

setDisplayProjection(virtualDpy, mainDpyInfo);

SurfaceComposerClient::closeGlobalTransaction();

orientation = mainDpyInfo.orientation;

}

}

debugNumFrames++;

ALOGV("Got codec NumFrames:%d", debugNumFrames);

cout<

callback->onData(buffers[bufIndex]->data(), size);

//if ((flags & MediaCodec::BUFFER_FLAG_CODECCONFIG) == 0)

//{

//fflush(rawFp);

//callback->FFlush();

//}

}

cout<

err = encoder->releaseOutputBuffer(bufIndex);

if (err != NO_ERROR) {

fprintf(stderr, "Unable to release output buffer (err=%d)\n",

err);

return err;

}

cout<

if ((flags & MediaCodec::BUFFER_FLAG_EOS) != 0) {

// Not expecting EOS from SurfaceFlinger.  Go with it.

ALOGD("Received end-of-stream");

cout<

mStopRequested = true;

}

break;

case -EAGAIN:                       // INFO_TRY_AGAIN_LATER

ALOGV("Got -EAGAIN, looping");

cout<

break;

case INFO_FORMAT_CHANGED:           // INFO_OUTPUT_FORMAT_CHANGED -1012

{

// format includes CSD, which we must provide to muxer

//sp newFormat;

//encoder->getOutputFormat(&newFormat);

//callback->formatChanged(newFormat);

ALOGV("Encoder format changed");

}

break;

case INFO_OUTPUT_BUFFERS_CHANGED:   // INFO_OUTPUT_BUFFERS_CHANGED -1014

// not expected for an encoder; handle it anyway

ALOGV("Encoder buffers changed");

cout<

err = encoder->getOutputBuffers(&buffers);

if (err != NO_ERROR) {

fprintf(stderr,

"Unable to get new output buffers (err=%d)\n", err);

return err;

}

break;

case INVALID_OPERATION:

fprintf(stderr, "Request for encoder buffer failed\n");

return err;

default:

fprintf(stderr,

"Got weird result %d from dequeueOutputBuffer\n", err);

return err;

}

}

ALOGV("Encoder stopping (req=%d)", mStopRequested);

cout<

return NO_ERROR;

}

int ScreenRecordImp::start(IScreenRecordCallback* callback)

{

cout<

status_t err;

// Start Binder thread pool.  MediaCodec needs to be able to receive

// messages from mediaserver.

sp self = ProcessState::self();

self->startThreadPool();

cout<

// Get main display parameters.

sp mainDpy = SurfaceComposerClient::getBuiltInDisplay(

ISurfaceComposer::eDisplayIdMain);

DisplayInfo mainDpyInfo;

err = SurfaceComposerClient::getDisplayInfo(mainDpy, &mainDpyInfo);

if (err != NO_ERROR) {

fprintf(stderr, "ERROR: unable to get display characteristics\n");

return err;

}

bool rotated = isDeviceRotated(mainDpyInfo.orientation);

if (mVideoWidth == 0) {

mVideoWidth = rotated ? mainDpyInfo.h : mainDpyInfo.w;

}

if (mVideoHeight == 0) {

mVideoHeight = rotated ? mainDpyInfo.w : mainDpyInfo.h;

}

cout<

// Configure and start the encoder.

sp encoder;

sp bufferProducer;

err = prepareEncoder(mainDpyInfo.fps, &encoder, &bufferProducer);

if (err != NO_ERROR) {

// fallback is defined for landscape; swap if we're in portrait

bool needSwap = mVideoWidth 

uint32_t newWidth = needSwap ? kFallbackHeight : kFallbackWidth;

uint32_t newHeight = needSwap ? kFallbackWidth : kFallbackHeight;

if (mVideoWidth != newWidth && mVideoHeight != newHeight) {

ALOGV("Retrying with 720p");

fprintf(stderr, "WARNING: failed at %dx%d, retrying at %dx%d\n",

mVideoWidth, mVideoHeight, newWidth, newHeight);

mVideoWidth = newWidth;

mVideoHeight = newHeight;

err = prepareEncoder(mainDpyInfo.fps, &encoder, &bufferProducer);

}

}

if (err != NO_ERROR) {

return err;

}

sp dpy;

err = prepareVirtualDisplay(mainDpyInfo, bufferProducer, &dpy);

if (err != NO_ERROR) {

encoder->release();

encoder.clear();

return err;

}

// Main encoder loop.

err = runEncoder(encoder,callback, mainDpy, dpy, mainDpyInfo.orientation);

if (err != NO_ERROR) {

encoder->release();

encoder.clear();

return err;

}

bufferProducer = NULL;

SurfaceComposerClient::destroyDisplay(dpy);

encoder->stop();

//muxer->stop();

encoder->release();

return 0;

}

void ScreenRecordImp::stop()

{

mStopRequested = true;

}

用法class ScreenRecordCallback:public IScreenRecordCallback

{

public:

virtual ~ScreenRecordCallback(){}

virtual void onData(void* pData, size_t size)

{

}

};

int main(int arg, char** arv)

{

ScreenRecordCallback callback;

ScreenRecord recorder

recorder.start(&callback);

return 0;

}

抓到屏幕码流后ScreenRecordCallback的onData会被回调，收到的数据存下来就是h264码流

mikefileLOCAL_PATH:= $(call my-dir)

include $(CLEAR_VARS)

LOCAL_SRC_FILES := \

screenrecord.cpp \

LOCAL_SHARED_LIBRARIES := \

libstagefright libmedia libutils libbinder libstagefright_foundation \

libjpeg libgui libcutils liblog libEGL libGLESv2

LOCAL_C_INCLUDES := \

frameworks/av/media/libstagefright \

frameworks/av/media/libstagefright/include \

$(TOP)/frameworks/native/include/media/openmax \

external/jpeg

LOCAL_CFLAGS += -Wno-multichar

LOCAL_MODULE_TAGS := optional

LOCAL_MODULE:= libscreenrecord

include $(BUILD_SHARED_LIBRARY)

后续继续实现Android推送码流到PC机,PC机能够解码显示。

原文：https://blog.csdn.net/star_ni/article/details/54948723

猫盟CFCA
关注
【Android 视频硬件编码】screenrecord.cpp 代码中编码流程分析
|~~~热爱生活、努力学习的小伙汁~~~|
10-29 1968
【安卓硬件编码学习】screenrecord.cpp 代码流程分析一、ScreenRecord.cpp1. Android.mk2. main() 主函数代码二、recordScreen(fileName) 录屏代码分析 本文主要学习如何实现在 Native C++层实现硬件编，参考的是 \frameworks\av\cmds\screenrecord\screenrecord.cpp， 我们主要关注的是编码相关，其他部分可以先忽略，为方便分析，我会把代码中一些不相干的先删了。 好，接下来废话不多说，我们来
Android c++屏幕实时录制
star_ni的博客
02-09 3153
功能:沿用Android cmds下的screenrecord代码，整理成可以供native程序调用的一个可以获取实时screen h264码流的一个库，分享一下！！ 头文件screenrecord.h #include class IScreenRecordCallback { public: virtual ~IScreenRecordCallback(){} virtual vo
利用 android mediaRecorder c++类进行视频编码
u011451108的博客
07-05 1325
基于android sdk6.0）的mediaRecorder c++编码简要分析
2024年C C++最全安卓-录屏录音录像_android mediacodec 录视频，2024年最新字节跳动C C++金三银四解析
最新发布
2401_84975828的博客
05-13 645
【代码】2024年C C++最全安卓-录屏录音录像_android mediacodec 录视频，2024年最新字节跳动C C++金三银四解析。
c语言安卓录屏,手写 Android 录屏直播
weixin_28684497的博客
05-18 520
简介观看手游直播时，我们观众端看到的是选手的屏幕上的内容，这是如何实现的呢？这篇博客将手写一个录屏直播 Demo，实现类似手游直播的效果获取屏幕数据很简单，Android 系统有提供对应的服务，难点在于传输数据到直播服务器，我们使用 RtmpDump 来传输 Rtmp 数据，由于 RtmpDump 使用 C 语言实现，我们还需要用到 NDK 开发，单单用 Java 无法实现哈，当然如果不怕麻烦的话...
android录屏代码简单例子
05-12
在Android平台上，录屏功能是开发者和用户都可能需要的一项实用功能。本篇文章将通过一个简单的例子，介绍如何在Android应用中实现录屏功能。我们将主要关注以下几个关键知识点： 1. **权限申请**：在Android中，...
自己用C++写的一个多功能简易录屏软件（附源码）
03-25
自己用C++写的一个多功能简易录屏软件Ericord（附源码） 由自己编写的一个简单的录屏软件，但功能样样齐全，可以满足日常需求。（可调整区域，可自动检测分辨率，可调整帧速率，可调整输出格式[mpg/avi格式都支持]...
Android 区域截屏及录屏DEMO
10-21
在Android平台上，实现区域截屏和录屏功能是开发者经常遇到的需求，这通常涉及到系统级权限的使用。本文将深入探讨如何在Android中构建这样的DEMO应用，包括关键的API介绍、实现步骤以及可能遇到的问题。 首先，...
QML for Android通过ScreenRecorder录制屏幕并保存为本地视频
06-23
在标题和描述中提到的"QML for Android通过ScreenRecorder录制屏幕并保存为本地视频"，涉及到的是利用Qt的QML模块来实现对Android设备屏幕的录制功能，并将录制内容存储为本地视频文件。这是一个相当实用的功能，...
C++ 录屏技术
05-09
一款简单的c++ 录屏技术，很实用
c++录屏源代码
10-20
使用ffmpeg插件，完成录屏功能，并且将录制的视频保存为MP4文件
Android5.0以上版本录屏实现代码(完整代码)
01-04
我录屏的方式是分别录制音频和视频，最后合并成mp4格式，比较麻烦，因为网上完整的教程比较少，所以我打算写一个完整版的，照着我的代码写完之后，至少是能够实现功能的，而不是简单的介绍下用法。 1既然是录制视频，我们应该有一个按钮控制开始和结束。 2在录制之前，需要先判断一下Android系统的版本是否大于5.0，并且动态申请一下权限（读写，录音，照相机），这一步可以在点开始按钮的时候执行　　 　　if (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE) != Packa
实现屏幕的录制功能
05-23
屏幕录制，通过代码实现屏幕的录制功能，android原生没有此功能。
android 5.0+录屏(音频+视频)示例demo
01-08
android 5.0+手机屏幕录制使用示例代码，包含音频+视频
Android录屏命令、Android录Gif、Android录视频
Liuqz2009的专栏
10-27 741
NoHttp开源地址：https://github.com/yanzhenjie/NoHttp NoHttp详细使用文档已发布，你想知道的全都有，请点我移步！ 版权声明：转载请注明本文转自严振杰的博客: http://blog.yanzhenjie.com 演示 　　大家看博客时经常看到下面这种图片，都很想知道怎么做的吧，好在自己写博客时也把操作录下来： 　　这个图是
android 截图,视频录制命令 screencap screenrecord screenshot
嵌入式开发，欢迎交流
04-10 4563
时间限制视频录制： screenrecord  --time-limit 20 /sdcard/demo.mp4 抓屏： screencap -p /sdcard/screen.png screenshot /sdcard/screen.png 视频录制命令screenrecord  # screenrecord --help                      
Android C/C++获取屏触屏输入设备、屏幕分辨率
Deep Lee的专栏
01-14 4182
#include <stdlib.h> #include <stdio.h> #include <gui/ISurfaceComposer.h> #include <gui/Surface.h> #include <gui/SurfaceComposerClient.h> #include <ui/DisplayInfo.h>...
Android代码获取屏幕内容,Android 获取屏幕的多种宽高信息的示例代码
weixin_30380991的博客
05-26 473
本文主要介绍了Android 获取屏幕的多种宽高信息的示例代码，分享给大家，具体如下：包含的宽高信息如下图所示：在模拟器上获取到的数据：08-26 07:19:32.712 7834-7834/com.czy.screeninfo E/MainActivity: getTotalScreenHeight 192008-26 07:19:33.505 7834-7834/com.czy.screen...
c++ android 手势识别,基本例程（4-1）手势识别C++ 和简单形状匹配
weixin_35414484的博客
05-30 786
opencv3.3+扩展库 /************************************************************************//*Description:手势检测先滤波去噪-->转换到HSV空间-->根据皮肤在HSV空间的分布做出阈值判断，这里用到了inRange函数，然后进行一下形态学的操作，去除噪声干扰，是手的边界更加清晰平滑--...
在C++中实现录制Android屏幕，并将屏幕数据实时生成Mat对象
04-24
您可以使用Android NDK将C代码嵌入到Android应用程序中，然后使用Android提供的MediaCodec和MediaMuxer API来录制屏幕并生成Mat对象。以下是一些实现步骤： 1. 使用Android NDK创建C代码文件。 2. 写C代码来打开屏幕捕捉器并捕捉屏幕。 3. 将屏幕数据提供给Android提供的MediaCodec API。 4. 将数据压缩并写入文件。 5. 将视频文件读取到Mat对象中。 希望这可以帮助您开始实现您的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值