blob: e732ba32e9d4f0ee31392c4b3771e439e59b513e (
plain)
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
|
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef MEDIA_GPU_VAAPI_VAAPI_JPEG_ENCODER_H_
#define MEDIA_GPU_VAAPI_VAAPI_JPEG_ENCODER_H_
#include <va/va.h>
#include <memory>
#include "base/macros.h"
#include "base/memory/scoped_refptr.h"
#include "media/gpu/media_gpu_export.h"
#include "ui/gfx/geometry/size.h"
namespace media {
class VaapiWrapper;
// A collection of methods that utilize VA-API hardware video encode
// acceleration on Intel systems. Provides functionality to allow plugging VAAPI
// HW acceleration into the JpegEncodeAccelerator framework.
//
// Clients are expected to manage VA surfaces and VA buffers created via
// VaapiWrapper, and pass them to this class.
class MEDIA_GPU_EXPORT VaapiJpegEncoder {
public:
// |vaapi_wrapper| should be initialized in
// VaapiWrapper::kEncodeConstantBitrate mode with VAProfileJPEGBaseline
// profile.
explicit VaapiJpegEncoder(scoped_refptr<VaapiWrapper> vaapi_wrapper);
VaapiJpegEncoder(const VaapiJpegEncoder&) = delete;
VaapiJpegEncoder& operator=(const VaapiJpegEncoder&) = delete;
~VaapiJpegEncoder();
// Encode a JPEG picture. It will fill VA-API parameters and call
// corresponding VA-API methods according to |input_size|.
// |exif_buffer| contains the EXIF data that will be inserted to the JPEG
// image.
// |exif_buffer_size| is the size of |exif_buffer|.
// |quality| is the JPEG image quality
// |surface_id| is the VA surface that contains input image.
// |output_buffer_id| is the ID of VA buffer that encoded image will be
// stored. The size of it should be at least as large as
// GetMaxCodedBufferSize().
// |exif_offset| is the offset where Exif data should be filled into.
// Return false on failure.
bool Encode(const gfx::Size& input_size,
const uint8_t* exif_buffer,
size_t exif_buffer_size,
int quality,
VASurfaceID surface_id,
VABufferID output_buffer_id,
size_t* exif_offset);
// Gets the maximum possible encoded result size.
// |size| is the dimension of the YUV image to be encoded.
static size_t GetMaxCodedBufferSize(const gfx::Size& size);
private:
scoped_refptr<VaapiWrapper> vaapi_wrapper_;
// |q_matrix_cached_|, |huff_table_param_cached_| and |slice_param_cached_|
// are created when Encode() is called the first time. After that, they will
// directly be used for all the subsequent Encode() calls.
std::unique_ptr<VAQMatrixBufferJPEG> q_matrix_cached_;
std::unique_ptr<VAHuffmanTableBufferJPEGBaseline> huff_table_param_cached_;
std::unique_ptr<VAEncSliceParameterBufferJPEG> slice_param_cached_;
};
} // namespace media
#endif // MEDIA_GPU_VAAPI_VAAPI_JPEG_ENCODER_H_
|
