1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
/*
* Copyright 2019 The libgav1 Authors
*
* 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.
*/
#ifndef LIBGAV1_SRC_GAV1_DECODER_H_
#define LIBGAV1_SRC_GAV1_DECODER_H_
#if defined(__cplusplus)
#include <cstddef>
#include <cstdint>
#include <memory>
#else
#include <stddef.h>
#include <stdint.h>
#endif // defined(__cplusplus)
// IWYU pragma: begin_exports
#include "gav1/decoder_buffer.h"
#include "gav1/decoder_settings.h"
#include "gav1/frame_buffer.h"
#include "gav1/status_code.h"
#include "gav1/symbol_visibility.h"
#include "gav1/version.h"
// IWYU pragma: end_exports
#if defined(__cplusplus)
extern "C" {
#endif
struct Libgav1Decoder;
typedef struct Libgav1Decoder Libgav1Decoder;
LIBGAV1_PUBLIC Libgav1StatusCode Libgav1DecoderCreate(
const Libgav1DecoderSettings* settings, Libgav1Decoder** decoder_out);
LIBGAV1_PUBLIC void Libgav1DecoderDestroy(Libgav1Decoder* decoder);
LIBGAV1_PUBLIC Libgav1StatusCode Libgav1DecoderEnqueueFrame(
Libgav1Decoder* decoder, const uint8_t* data, size_t size,
int64_t user_private_data, void* buffer_private_data);
LIBGAV1_PUBLIC Libgav1StatusCode Libgav1DecoderDequeueFrame(
Libgav1Decoder* decoder, const Libgav1DecoderBuffer** out_ptr);
LIBGAV1_PUBLIC Libgav1StatusCode
Libgav1DecoderSignalEOS(Libgav1Decoder* decoder);
LIBGAV1_PUBLIC int Libgav1DecoderGetMaxBitdepth(void);
#if defined(__cplusplus)
} // extern "C"
namespace libgav1 {
// Forward declaration.
class DecoderImpl;
class LIBGAV1_PUBLIC Decoder {
public:
Decoder();
~Decoder();
// Init must be called exactly once per instance. Subsequent calls will do
// nothing. If |settings| is nullptr, the decoder will be initialized with
// default settings. Returns kStatusOk on success, an error status otherwise.
StatusCode Init(const DecoderSettings* settings);
// Enqueues a compressed frame to be decoded.
//
// This function returns:
// * kStatusOk on success
// * kStatusTryAgain if the decoder queue is full
// * an error status otherwise.
//
// |user_private_data| may be used to associate application specific private
// data with the compressed frame. It will be copied to the user_private_data
// field of the DecoderBuffer returned by the corresponding |DequeueFrame()|
// call.
//
// NOTE: |EnqueueFrame()| does not copy the data. Therefore, after a
// successful |EnqueueFrame()| call, the caller must keep the |data| buffer
// alive until:
// 1) If |settings_.release_input_buffer| is not nullptr, then |data| buffer
// must be kept alive until release_input_buffer is called with the
// |buffer_private_data| passed into this EnqueueFrame call.
// 2) If |settings_.release_input_buffer| is nullptr, then |data| buffer must
// be kept alive until the corresponding DequeueFrame() call is completed.
//
// If the call to |EnqueueFrame()| is not successful, then libgav1 will not
// hold any references to the |data| buffer. |settings_.release_input_buffer|
// callback will not be called in that case.
StatusCode EnqueueFrame(const uint8_t* data, size_t size,
int64_t user_private_data, void* buffer_private_data);
// Dequeues a decompressed frame. If there are enqueued compressed frames,
// decodes one and sets |*out_ptr| to the last displayable frame in the
// compressed frame. If there are no displayable frames available, sets
// |*out_ptr| to nullptr.
//
// Returns kStatusOk on success. Returns kStatusNothingToDequeue if there are
// no enqueued frames (in this case out_ptr will always be set to nullptr).
// Returns one of the other error statuses if there is an error.
//
// If |settings_.blocking_dequeue| is false and the decoder is operating in
// frame parallel mode (|settings_.frame_parallel| is true and the video
// stream passes the decoder's heuristics for enabling frame parallel mode),
// then this call will return kStatusTryAgain if an enqueued frame is not yet
// decoded (it is a non blocking call in this case). In all other cases, this
// call will block until an enqueued frame has been decoded.
StatusCode DequeueFrame(const DecoderBuffer** out_ptr);
// Signals the end of stream.
//
// In non-frame-parallel mode, this function will release all the frames held
// by the decoder. If the frame buffers were allocated by libgav1, then the
// pointer obtained by the prior DequeueFrame call will no longer be valid. If
// the frame buffers were allocated by the application, then any references
// that libgav1 is holding on to will be released.
//
// Once this function returns successfully, the decoder state will be reset
// and the decoder is ready to start decoding a new coded video sequence.
StatusCode SignalEOS();
// Returns the maximum bitdepth that is supported by this decoder.
static int GetMaxBitdepth();
private:
DecoderSettings settings_;
// The object is initialized if and only if impl_ != nullptr.
std::unique_ptr<DecoderImpl> impl_;
};
} // namespace libgav1
#endif // defined(__cplusplus)
#endif // LIBGAV1_SRC_GAV1_DECODER_H_
|
