blob: 5204c993cd7de6b1dc7fd7c7f8173024af0e858a
1 | /* |
2 | * Copyright (c) 2010, Google, Inc. |
3 | * |
4 | * This file is part of FFmpeg. |
5 | * |
6 | * FFmpeg is free software; you can redistribute it and/or |
7 | * modify it under the terms of the GNU Lesser General Public |
8 | * License as published by the Free Software Foundation; either |
9 | * version 2.1 of the License, or (at your option) any later version. |
10 | * |
11 | * FFmpeg is distributed in the hope that it will be useful, |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 | * Lesser General Public License for more details. |
15 | * |
16 | * You should have received a copy of the GNU Lesser General Public |
17 | * License along with FFmpeg; if not, write to the Free Software |
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
19 | */ |
20 | |
21 | /** |
22 | * @file |
23 | * VP8/9 decoder support via libvpx |
24 | */ |
25 | |
26 | #define VPX_CODEC_DISABLE_COMPAT 1 |
27 | #include <vpx/vpx_decoder.h> |
28 | #include <vpx/vp8dx.h> |
29 | |
30 | #include "libavutil/common.h" |
31 | #include "libavutil/imgutils.h" |
32 | #include "libavutil/intreadwrite.h" |
33 | #include "avcodec.h" |
34 | #include "internal.h" |
35 | #include "libvpx.h" |
36 | #include "profiles.h" |
37 | |
38 | typedef struct VPxDecoderContext { |
39 | struct vpx_codec_ctx decoder; |
40 | struct vpx_codec_ctx decoder_alpha; |
41 | int has_alpha_channel; |
42 | } VPxContext; |
43 | |
44 | static av_cold int vpx_init(AVCodecContext *avctx, |
45 | const struct vpx_codec_iface *iface, |
46 | int is_alpha_decoder) |
47 | { |
48 | VPxContext *ctx = avctx->priv_data; |
49 | struct vpx_codec_dec_cfg deccfg = { |
50 | /* token partitions+1 would be a decent choice */ |
51 | .threads = FFMIN(avctx->thread_count, 16) |
52 | }; |
53 | |
54 | av_log(avctx, AV_LOG_INFO, "%s\n", vpx_codec_version_str()); |
55 | av_log(avctx, AV_LOG_VERBOSE, "%s\n", vpx_codec_build_config()); |
56 | |
57 | if (vpx_codec_dec_init( |
58 | is_alpha_decoder ? &ctx->decoder_alpha : &ctx->decoder, |
59 | iface, &deccfg, 0) != VPX_CODEC_OK) { |
60 | const char *error = vpx_codec_error(&ctx->decoder); |
61 | av_log(avctx, AV_LOG_ERROR, "Failed to initialize decoder: %s\n", |
62 | error); |
63 | return AVERROR(EINVAL); |
64 | } |
65 | |
66 | return 0; |
67 | } |
68 | |
69 | // returns 0 on success, AVERROR_INVALIDDATA otherwise |
70 | static int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img, |
71 | int has_alpha_channel) |
72 | { |
73 | #if VPX_IMAGE_ABI_VERSION >= 3 |
74 | static const enum AVColorSpace colorspaces[8] = { |
75 | AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_BT470BG, AVCOL_SPC_BT709, AVCOL_SPC_SMPTE170M, |
76 | AVCOL_SPC_SMPTE240M, AVCOL_SPC_BT2020_NCL, AVCOL_SPC_RESERVED, AVCOL_SPC_RGB, |
77 | }; |
78 | #if VPX_IMAGE_ABI_VERSION >= 4 |
79 | static const enum AVColorRange color_ranges[] = { |
80 | AVCOL_RANGE_MPEG, AVCOL_RANGE_JPEG |
81 | }; |
82 | avctx->color_range = color_ranges[img->range]; |
83 | #endif |
84 | avctx->colorspace = colorspaces[img->cs]; |
85 | #endif |
86 | if (avctx->codec_id == AV_CODEC_ID_VP8 && img->fmt != VPX_IMG_FMT_I420) |
87 | return AVERROR_INVALIDDATA; |
88 | switch (img->fmt) { |
89 | case VPX_IMG_FMT_I420: |
90 | if (avctx->codec_id == AV_CODEC_ID_VP9) |
91 | avctx->profile = FF_PROFILE_VP9_0; |
92 | avctx->pix_fmt = |
93 | has_alpha_channel ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P; |
94 | return 0; |
95 | #if CONFIG_LIBVPX_VP9_DECODER |
96 | case VPX_IMG_FMT_I422: |
97 | avctx->profile = FF_PROFILE_VP9_1; |
98 | avctx->pix_fmt = AV_PIX_FMT_YUV422P; |
99 | return 0; |
100 | #if VPX_IMAGE_ABI_VERSION >= 3 |
101 | case VPX_IMG_FMT_I440: |
102 | avctx->profile = FF_PROFILE_VP9_1; |
103 | avctx->pix_fmt = AV_PIX_FMT_YUV440P; |
104 | return 0; |
105 | #endif |
106 | case VPX_IMG_FMT_I444: |
107 | avctx->profile = FF_PROFILE_VP9_1; |
108 | #if VPX_IMAGE_ABI_VERSION >= 3 |
109 | avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ? |
110 | AV_PIX_FMT_GBRP : AV_PIX_FMT_YUV444P; |
111 | #else |
112 | avctx->pix_fmt = AV_PIX_FMT_YUV444P; |
113 | #endif |
114 | return 0; |
115 | #ifdef VPX_IMG_FMT_HIGHBITDEPTH |
116 | case VPX_IMG_FMT_I42016: |
117 | avctx->profile = FF_PROFILE_VP9_2; |
118 | if (img->bit_depth == 10) { |
119 | avctx->pix_fmt = AV_PIX_FMT_YUV420P10; |
120 | return 0; |
121 | } else if (img->bit_depth == 12) { |
122 | avctx->pix_fmt = AV_PIX_FMT_YUV420P12; |
123 | return 0; |
124 | } else { |
125 | return AVERROR_INVALIDDATA; |
126 | } |
127 | case VPX_IMG_FMT_I42216: |
128 | avctx->profile = FF_PROFILE_VP9_3; |
129 | if (img->bit_depth == 10) { |
130 | avctx->pix_fmt = AV_PIX_FMT_YUV422P10; |
131 | return 0; |
132 | } else if (img->bit_depth == 12) { |
133 | avctx->pix_fmt = AV_PIX_FMT_YUV422P12; |
134 | return 0; |
135 | } else { |
136 | return AVERROR_INVALIDDATA; |
137 | } |
138 | #if VPX_IMAGE_ABI_VERSION >= 3 |
139 | case VPX_IMG_FMT_I44016: |
140 | avctx->profile = FF_PROFILE_VP9_3; |
141 | if (img->bit_depth == 10) { |
142 | avctx->pix_fmt = AV_PIX_FMT_YUV440P10; |
143 | return 0; |
144 | } else if (img->bit_depth == 12) { |
145 | avctx->pix_fmt = AV_PIX_FMT_YUV440P12; |
146 | return 0; |
147 | } else { |
148 | return AVERROR_INVALIDDATA; |
149 | } |
150 | #endif |
151 | case VPX_IMG_FMT_I44416: |
152 | avctx->profile = FF_PROFILE_VP9_3; |
153 | if (img->bit_depth == 10) { |
154 | #if VPX_IMAGE_ABI_VERSION >= 3 |
155 | avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ? |
156 | AV_PIX_FMT_GBRP10 : AV_PIX_FMT_YUV444P10; |
157 | #else |
158 | avctx->pix_fmt = AV_PIX_FMT_YUV444P10; |
159 | #endif |
160 | return 0; |
161 | } else if (img->bit_depth == 12) { |
162 | #if VPX_IMAGE_ABI_VERSION >= 3 |
163 | avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ? |
164 | AV_PIX_FMT_GBRP12 : AV_PIX_FMT_YUV444P12; |
165 | #else |
166 | avctx->pix_fmt = AV_PIX_FMT_YUV444P12; |
167 | #endif |
168 | return 0; |
169 | } else { |
170 | return AVERROR_INVALIDDATA; |
171 | } |
172 | #endif |
173 | #endif |
174 | default: |
175 | return AVERROR_INVALIDDATA; |
176 | } |
177 | } |
178 | |
179 | static int decode_frame(AVCodecContext *avctx, vpx_codec_ctx_t *decoder, |
180 | uint8_t *data, uint32_t data_sz) |
181 | { |
182 | if (vpx_codec_decode(decoder, data, data_sz, NULL, 0) != VPX_CODEC_OK) { |
183 | const char *error = vpx_codec_error(decoder); |
184 | const char *detail = vpx_codec_error_detail(decoder); |
185 | |
186 | av_log(avctx, AV_LOG_ERROR, "Failed to decode frame: %s\n", error); |
187 | if (detail) { |
188 | av_log(avctx, AV_LOG_ERROR, " Additional information: %s\n", |
189 | detail); |
190 | } |
191 | return AVERROR_INVALIDDATA; |
192 | } |
193 | return 0; |
194 | } |
195 | |
196 | static int vpx_decode(AVCodecContext *avctx, |
197 | void *data, int *got_frame, AVPacket *avpkt) |
198 | { |
199 | VPxContext *ctx = avctx->priv_data; |
200 | AVFrame *picture = data; |
201 | const void *iter = NULL; |
202 | const void *iter_alpha = NULL; |
203 | struct vpx_image *img, *img_alpha; |
204 | int ret; |
205 | uint8_t *side_data = NULL; |
206 | int side_data_size = 0; |
207 | |
208 | ret = decode_frame(avctx, &ctx->decoder, avpkt->data, avpkt->size); |
209 | if (ret) |
210 | return ret; |
211 | |
212 | side_data = av_packet_get_side_data(avpkt, |
213 | AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL, |
214 | &side_data_size); |
215 | if (side_data_size > 1) { |
216 | const uint64_t additional_id = AV_RB64(side_data); |
217 | side_data += 8; |
218 | side_data_size -= 8; |
219 | if (additional_id == 1) { // 1 stands for alpha channel data. |
220 | if (!ctx->has_alpha_channel) { |
221 | ctx->has_alpha_channel = 1; |
222 | ret = vpx_init(avctx, |
223 | #if CONFIG_LIBVPX_VP8_DECODER && CONFIG_LIBVPX_VP9_DECODER |
224 | (avctx->codec_id == AV_CODEC_ID_VP8) ? |
225 | &vpx_codec_vp8_dx_algo : &vpx_codec_vp9_dx_algo, |
226 | #elif CONFIG_LIBVPX_VP8_DECODER |
227 | &vpx_codec_vp8_dx_algo, |
228 | #else |
229 | &vpx_codec_vp9_dx_algo, |
230 | #endif |
231 | 1); |
232 | if (ret) |
233 | return ret; |
234 | } |
235 | ret = decode_frame(avctx, &ctx->decoder_alpha, side_data, |
236 | side_data_size); |
237 | if (ret) |
238 | return ret; |
239 | } |
240 | } |
241 | |
242 | if ((img = vpx_codec_get_frame(&ctx->decoder, &iter)) && |
243 | (!ctx->has_alpha_channel || |
244 | (img_alpha = vpx_codec_get_frame(&ctx->decoder_alpha, &iter_alpha)))) { |
245 | uint8_t *planes[4]; |
246 | int linesizes[4]; |
247 | if ((ret = set_pix_fmt(avctx, img, ctx->has_alpha_channel)) < 0) { |
248 | #ifdef VPX_IMG_FMT_HIGHBITDEPTH |
249 | av_log(avctx, AV_LOG_ERROR, "Unsupported output colorspace (%d) / bit_depth (%d)\n", |
250 | img->fmt, img->bit_depth); |
251 | #else |
252 | av_log(avctx, AV_LOG_ERROR, "Unsupported output colorspace (%d) / bit_depth (%d)\n", |
253 | img->fmt, 8); |
254 | #endif |
255 | return ret; |
256 | } |
257 | |
258 | if ((int) img->d_w != avctx->width || (int) img->d_h != avctx->height) { |
259 | av_log(avctx, AV_LOG_INFO, "dimension change! %dx%d -> %dx%d\n", |
260 | avctx->width, avctx->height, img->d_w, img->d_h); |
261 | ret = ff_set_dimensions(avctx, img->d_w, img->d_h); |
262 | if (ret < 0) |
263 | return ret; |
264 | } |
265 | if ((ret = ff_get_buffer(avctx, picture, 0)) < 0) |
266 | return ret; |
267 | |
268 | planes[0] = img->planes[VPX_PLANE_Y]; |
269 | planes[1] = img->planes[VPX_PLANE_U]; |
270 | planes[2] = img->planes[VPX_PLANE_V]; |
271 | planes[3] = |
272 | ctx->has_alpha_channel ? img_alpha->planes[VPX_PLANE_Y] : NULL; |
273 | linesizes[0] = img->stride[VPX_PLANE_Y]; |
274 | linesizes[1] = img->stride[VPX_PLANE_U]; |
275 | linesizes[2] = img->stride[VPX_PLANE_V]; |
276 | linesizes[3] = |
277 | ctx->has_alpha_channel ? img_alpha->stride[VPX_PLANE_Y] : 0; |
278 | av_image_copy(picture->data, picture->linesize, (const uint8_t**)planes, |
279 | linesizes, avctx->pix_fmt, img->d_w, img->d_h); |
280 | *got_frame = 1; |
281 | } |
282 | return avpkt->size; |
283 | } |
284 | |
285 | static av_cold int vpx_free(AVCodecContext *avctx) |
286 | { |
287 | VPxContext *ctx = avctx->priv_data; |
288 | vpx_codec_destroy(&ctx->decoder); |
289 | if (ctx->has_alpha_channel) |
290 | vpx_codec_destroy(&ctx->decoder_alpha); |
291 | return 0; |
292 | } |
293 | |
294 | #if CONFIG_LIBVPX_VP8_DECODER |
295 | static av_cold int vp8_init(AVCodecContext *avctx) |
296 | { |
297 | return vpx_init(avctx, &vpx_codec_vp8_dx_algo, 0); |
298 | } |
299 | |
300 | AVCodec ff_libvpx_vp8_decoder = { |
301 | .name = "libvpx", |
302 | .long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"), |
303 | .type = AVMEDIA_TYPE_VIDEO, |
304 | .id = AV_CODEC_ID_VP8, |
305 | .priv_data_size = sizeof(VPxContext), |
306 | .init = vp8_init, |
307 | .close = vpx_free, |
308 | .decode = vpx_decode, |
309 | .capabilities = AV_CODEC_CAP_AUTO_THREADS | AV_CODEC_CAP_DR1, |
310 | }; |
311 | #endif /* CONFIG_LIBVPX_VP8_DECODER */ |
312 | |
313 | #if CONFIG_LIBVPX_VP9_DECODER |
314 | static av_cold int vp9_init(AVCodecContext *avctx) |
315 | { |
316 | return vpx_init(avctx, &vpx_codec_vp9_dx_algo, 0); |
317 | } |
318 | |
319 | AVCodec ff_libvpx_vp9_decoder = { |
320 | .name = "libvpx-vp9", |
321 | .long_name = NULL_IF_CONFIG_SMALL("libvpx VP9"), |
322 | .type = AVMEDIA_TYPE_VIDEO, |
323 | .id = AV_CODEC_ID_VP9, |
324 | .priv_data_size = sizeof(VPxContext), |
325 | .init = vp9_init, |
326 | .close = vpx_free, |
327 | .decode = vpx_decode, |
328 | .capabilities = AV_CODEC_CAP_AUTO_THREADS | AV_CODEC_CAP_DR1, |
329 | .init_static_data = ff_vp9_init_static, |
330 | .profiles = NULL_IF_CONFIG_SMALL(ff_vp9_profiles), |
331 | }; |
332 | #endif /* CONFIG_LIBVPX_VP9_DECODER */ |
333 |