You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
95 lines
3.6 KiB
95 lines
3.6 KiB
// Copyright (C) 2017 The Android Open Source Project
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#pragma once
|
|
|
|
#include <stdint.h> // for uint32_t
|
|
#include <stdbool.h>
|
|
|
|
#include "display_agent.h" // for QAndroidDisplay...
|
|
#include "multi_display_agent.h"
|
|
|
|
// This callback will be called in the following scenarios:
|
|
//
|
|
// 1) The encoding has been stopped
|
|
// 2) The encoding is finished
|
|
// 3) An error has occurred while encoding was trying to finish.
|
|
//
|
|
// When screen_recorder_stop_async() is called, this callback will get called,
|
|
// with success set to 0. There is some time elapsed when we want to stop
|
|
// recording and when the encoding is actually finished, so we'll get a second
|
|
// call to the callback once the encoding is finished, with success set to 1. If
|
|
// any errors occur while stopping the recording, success will be set to -1.
|
|
typedef enum {
|
|
RECORD_START_INITIATED,
|
|
RECORD_STARTED,
|
|
RECORD_START_FAILED,
|
|
RECORD_STOP_INITIATED,
|
|
RECORD_STOPPED,
|
|
RECORD_STOP_FAILED,
|
|
} RecordingStatus;
|
|
|
|
typedef enum {
|
|
RECORDER_STARTING,
|
|
RECORDER_RECORDING,
|
|
RECORDER_STOPPING,
|
|
RECORDER_STOPPED,
|
|
} RecorderState;
|
|
|
|
typedef struct {
|
|
RecorderState state;
|
|
uint32_t displayId;
|
|
} RecorderStates;
|
|
|
|
typedef void (*RecordingCallback)(void* opaque, RecordingStatus status);
|
|
|
|
typedef struct RecordingInfo {
|
|
const char* fileName;
|
|
uint32_t width;
|
|
uint32_t height;
|
|
uint32_t videoBitrate;
|
|
uint32_t timeLimit;
|
|
uint32_t fps;
|
|
uint32_t displayId;
|
|
RecordingCallback cb;
|
|
void* opaque;
|
|
} RecordingInfo;
|
|
|
|
// Initializes internal global structure. Call this before doing any recording
|
|
// operations. |w| and |h| are the FrameBuffer width and height. |dpy_agent| is
|
|
// the display agent for recording in guest mode. If |dpy_agent| is NULL, then
|
|
// the recorder will assume it is in host mode.
|
|
extern void screen_recorder_init(uint32_t w,
|
|
uint32_t h,
|
|
const QAndroidDisplayAgent* dpy_agent,
|
|
const QAndroidMultiDisplayAgent* mdpy_agent);
|
|
// Starts recording the screen. When stopped, the file will be saved as
|
|
// |info->filename|. Set |async| true do not block as recording initialization
|
|
// takes time. Returns true if recorder started recording, false if it failed.
|
|
extern bool screen_recorder_start(const RecordingInfo* info, bool async);
|
|
// Stop recording. After calling this function, the encoder will stop processing
|
|
// frames. The encoder still needs to process any remaining frames it has, so
|
|
// calling this does not mean that the encoder has finished and |filename| is
|
|
// ready. Attach a RecordingStoppedCallback to get an update when the encoder
|
|
// has finished. Set |async| to false if you want to block until recording is
|
|
// finished.
|
|
extern bool screen_recorder_stop(bool async);
|
|
// Get the recorder's current state.
|
|
extern RecorderStates screen_recorder_state_get(void);
|
|
// Starts the shared memory region. Note that the desired framerate
|
|
// can be ignored.
|
|
extern const char* start_shared_memory_module(int desiredFps);
|
|
// Stops the webrtc module
|
|
extern bool stop_shared_memory_module();
|