lavc/aacpsdsp: use ptrdiff_t for stride in hybrid_analysis
[ffmpeg.git] / libavcodec / libvpxdec.c
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
248         if (img->d_w > img->w || img->d_h > img->h) {
249             av_log(avctx, AV_LOG_ERROR, "Display dimensions %dx%d exceed storage %dx%d\n",
250                    img->d_w, img->d_h, img->w, img->h);
251             return AVERROR_EXTERNAL;
252         }
253
254         if ((ret = set_pix_fmt(avctx, img, ctx->has_alpha_channel)) < 0) {
255 #ifdef VPX_IMG_FMT_HIGHBITDEPTH
256             av_log(avctx, AV_LOG_ERROR, "Unsupported output colorspace (%d) / bit_depth (%d)\n",
257                    img->fmt, img->bit_depth);
258 #else
259             av_log(avctx, AV_LOG_ERROR, "Unsupported output colorspace (%d) / bit_depth (%d)\n",
260                    img->fmt, 8);
261 #endif
262             return ret;
263         }
264
265         if ((int) img->d_w != avctx->width || (int) img->d_h != avctx->height) {
266             av_log(avctx, AV_LOG_INFO, "dimension change! %dx%d -> %dx%d\n",
267                    avctx->width, avctx->height, img->d_w, img->d_h);
268             ret = ff_set_dimensions(avctx, img->d_w, img->d_h);
269             if (ret < 0)
270                 return ret;
271         }
272         if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
273             return ret;
274
275         planes[0] = img->planes[VPX_PLANE_Y];
276         planes[1] = img->planes[VPX_PLANE_U];
277         planes[2] = img->planes[VPX_PLANE_V];
278         planes[3] =
279             ctx->has_alpha_channel ? img_alpha->planes[VPX_PLANE_Y] : NULL;
280         linesizes[0] = img->stride[VPX_PLANE_Y];
281         linesizes[1] = img->stride[VPX_PLANE_U];
282         linesizes[2] = img->stride[VPX_PLANE_V];
283         linesizes[3] =
284             ctx->has_alpha_channel ? img_alpha->stride[VPX_PLANE_Y] : 0;
285         av_image_copy(picture->data, picture->linesize, (const uint8_t**)planes,
286                       linesizes, avctx->pix_fmt, img->d_w, img->d_h);
287         *got_frame           = 1;
288     }
289     return avpkt->size;
290 }
291
292 static av_cold int vpx_free(AVCodecContext *avctx)
293 {
294     VPxContext *ctx = avctx->priv_data;
295     vpx_codec_destroy(&ctx->decoder);
296     if (ctx->has_alpha_channel)
297         vpx_codec_destroy(&ctx->decoder_alpha);
298     return 0;
299 }
300
301 #if CONFIG_LIBVPX_VP8_DECODER
302 static av_cold int vp8_init(AVCodecContext *avctx)
303 {
304     return vpx_init(avctx, &vpx_codec_vp8_dx_algo, 0);
305 }
306
307 AVCodec ff_libvpx_vp8_decoder = {
308     .name           = "libvpx",
309     .long_name      = NULL_IF_CONFIG_SMALL("libvpx VP8"),
310     .type           = AVMEDIA_TYPE_VIDEO,
311     .id             = AV_CODEC_ID_VP8,
312     .priv_data_size = sizeof(VPxContext),
313     .init           = vp8_init,
314     .close          = vpx_free,
315     .decode         = vpx_decode,
316     .capabilities   = AV_CODEC_CAP_AUTO_THREADS | AV_CODEC_CAP_DR1,
317 };
318 #endif /* CONFIG_LIBVPX_VP8_DECODER */
319
320 #if CONFIG_LIBVPX_VP9_DECODER
321 static av_cold int vp9_init(AVCodecContext *avctx)
322 {
323     return vpx_init(avctx, &vpx_codec_vp9_dx_algo, 0);
324 }
325
326 AVCodec ff_libvpx_vp9_decoder = {
327     .name           = "libvpx-vp9",
328     .long_name      = NULL_IF_CONFIG_SMALL("libvpx VP9"),
329     .type           = AVMEDIA_TYPE_VIDEO,
330     .id             = AV_CODEC_ID_VP9,
331     .priv_data_size = sizeof(VPxContext),
332     .init           = vp9_init,
333     .close          = vpx_free,
334     .decode         = vpx_decode,
335     .capabilities   = AV_CODEC_CAP_AUTO_THREADS | AV_CODEC_CAP_DR1,
336     .init_static_data = ff_vp9_init_static,
337     .profiles       = NULL_IF_CONFIG_SMALL(ff_vp9_profiles),
338 };
339 #endif /* CONFIG_LIBVPX_VP9_DECODER */