0d0eae0538bc7b1a9ac24213ba3cacffd0557c75
[vlc.git] / modules / codec / vpx.c
1 /*****************************************************************************
2  * vpx.c: libvpx decoder (VP8/VP9) module
3  *****************************************************************************
4  * Copyright (C) 2013 Rafaël Carré
5  *
6  * Authors: Rafaël Carré <funman@videolanorg>
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU Lesser General Public License as published by
10  * the Free Software Foundation; either version 2.1 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
21  *****************************************************************************/
22
23 /*****************************************************************************
24  * Preamble
25  *****************************************************************************/
26 #ifdef HAVE_CONFIG_H
27 # include "config.h"
28 #endif
29
30 #include <vlc_common.h>
31 #include <vlc_plugin.h>
32 #include <vlc_codec.h>
33
34 #include <vpx/vpx_decoder.h>
35 #include <vpx/vp8dx.h>
36
37 #ifdef ENABLE_SOUT
38 # include <vpx/vpx_encoder.h>
39 # include <vpx/vp8cx.h>
40 #endif
41
42 /****************************************************************************
43  * Local prototypes
44  ****************************************************************************/
45 static int OpenDecoder(vlc_object_t *);
46 static void CloseDecoder(vlc_object_t *);
47 #ifdef ENABLE_SOUT
48 static const char *const ppsz_sout_options[] = { "quality-mode", NULL };
49 static int OpenEncoder(vlc_object_t *);
50 static void CloseEncoder(vlc_object_t *);
51 static block_t *Encode(encoder_t *p_enc, picture_t *p_pict);
52
53 #define QUALITY_MODE_TEXT N_("Quality mode")
54 #define QUALITY_MODE_LONGTEXT N_("Quality setting which will determine max encoding time\n" \
55         " - 0: Good quality\n"\
56         " - 1: Realtime\n"\
57         " - 2: Best quality")
58 #endif
59
60 /*****************************************************************************
61  * Module descriptor
62  *****************************************************************************/
63
64 vlc_module_begin ()
65     set_shortname("vpx")
66     set_description(N_("WebM video decoder"))
67     set_capability("video decoder", 60)
68     set_callbacks(OpenDecoder, CloseDecoder)
69     set_category(CAT_INPUT)
70     set_subcategory(SUBCAT_INPUT_VCODEC)
71 #ifdef ENABLE_SOUT
72     add_submodule()
73     set_shortname("vpx")
74     set_capability("encoder", 60)
75     set_description(N_("WebM video encoder"))
76     set_callbacks(OpenEncoder, CloseEncoder)
77 #   define ENC_CFG_PREFIX "sout-vpx-"
78     add_integer( ENC_CFG_PREFIX "quality-mode", VPX_DL_GOOD_QUALITY, QUALITY_MODE_TEXT,
79                  QUALITY_MODE_LONGTEXT, true )
80         change_integer_range( 0, 2 )
81 #endif
82 vlc_module_end ()
83
84 static void vpx_err_msg(vlc_object_t *this, struct vpx_codec_ctx *ctx,
85                         const char *msg)
86 {
87     const char *error  = vpx_codec_error(ctx);
88     const char *detail = vpx_codec_error_detail(ctx);
89     if (!detail)
90         detail = "no specific information";
91     msg_Err(this, msg, error, detail);
92 }
93
94 #define VPX_ERR(this, ctx, msg) vpx_err_msg(VLC_OBJECT(this), ctx, msg ": %s (%s)")
95
96 /*****************************************************************************
97  * decoder_sys_t: libvpx decoder descriptor
98  *****************************************************************************/
99 typedef struct
100 {
101     struct vpx_codec_ctx ctx;
102 } decoder_sys_t;
103
104 static const struct
105 {
106     vlc_fourcc_t     i_chroma;
107     enum vpx_img_fmt i_chroma_id;
108     uint8_t          i_bitdepth;
109     uint8_t          i_needs_hack;
110
111 } chroma_table[] =
112 {
113     { VLC_CODEC_I420, VPX_IMG_FMT_I420, 8, 0 },
114     { VLC_CODEC_I422, VPX_IMG_FMT_I422, 8, 0 },
115     { VLC_CODEC_I444, VPX_IMG_FMT_I444, 8, 0 },
116     { VLC_CODEC_I440, VPX_IMG_FMT_I440, 8, 0 },
117
118     { VLC_CODEC_YV12, VPX_IMG_FMT_YV12, 8, 0 },
119     { VLC_CODEC_YUVA, VPX_IMG_FMT_444A, 8, 0 },
120     { VLC_CODEC_YUYV, VPX_IMG_FMT_YUY2, 8, 0 },
121     { VLC_CODEC_UYVY, VPX_IMG_FMT_UYVY, 8, 0 },
122     { VLC_CODEC_YVYU, VPX_IMG_FMT_YVYU, 8, 0 },
123
124     { VLC_CODEC_RGB15, VPX_IMG_FMT_RGB555, 8, 0 },
125     { VLC_CODEC_RGB16, VPX_IMG_FMT_RGB565, 8, 0 },
126     { VLC_CODEC_RGB24, VPX_IMG_FMT_RGB24, 8, 0 },
127     { VLC_CODEC_RGB32, VPX_IMG_FMT_RGB32, 8, 0 },
128
129     { VLC_CODEC_ARGB, VPX_IMG_FMT_ARGB, 8, 0 },
130     { VLC_CODEC_BGRA, VPX_IMG_FMT_ARGB_LE, 8, 0 },
131
132     { VLC_CODEC_GBR_PLANAR, VPX_IMG_FMT_I444, 8, 1 },
133     { VLC_CODEC_GBR_PLANAR_10L, VPX_IMG_FMT_I44416, 10, 1 },
134
135     { VLC_CODEC_I420_10L, VPX_IMG_FMT_I42016, 10, 0 },
136     { VLC_CODEC_I422_10L, VPX_IMG_FMT_I42216, 10, 0 },
137     { VLC_CODEC_I444_10L, VPX_IMG_FMT_I44416, 10, 0 },
138
139     { VLC_CODEC_I420_12L, VPX_IMG_FMT_I42016, 12, 0 },
140     { VLC_CODEC_I422_12L, VPX_IMG_FMT_I42216, 12, 0 },
141     { VLC_CODEC_I444_12L, VPX_IMG_FMT_I44416, 12, 0 },
142
143     { VLC_CODEC_I444_16L, VPX_IMG_FMT_I44416, 16, 0 },
144 };
145
146 static vlc_fourcc_t FindVlcChroma( struct vpx_image *img )
147 {
148     uint8_t hack = (img->fmt & VPX_IMG_FMT_I444) && (img->cs == VPX_CS_SRGB);
149
150     for( unsigned int i = 0; i < ARRAY_SIZE(chroma_table); i++ )
151         if( chroma_table[i].i_chroma_id == img->fmt &&
152             chroma_table[i].i_bitdepth == img->bit_depth &&
153             chroma_table[i].i_needs_hack == hack )
154             return chroma_table[i].i_chroma;
155
156     return 0;
157 }
158
159 /****************************************************************************
160  * Decode: the whole thing
161  ****************************************************************************/
162 static int Decode(decoder_t *dec, block_t *block)
163 {
164     decoder_sys_t *p_sys = dec->p_sys;
165     struct vpx_codec_ctx *ctx = &p_sys->ctx;
166
167     if (block == NULL) /* No Drain */
168         return VLCDEC_SUCCESS;
169
170     if (block->i_flags & (BLOCK_FLAG_CORRUPTED)) {
171         block_Release(block);
172         return VLCDEC_SUCCESS;
173     }
174
175     /* Associate packet PTS with decoded frame */
176     vlc_tick_t *pkt_pts = malloc(sizeof(*pkt_pts));
177     if (!pkt_pts) {
178         block_Release(block);
179         return VLCDEC_SUCCESS;
180     }
181
182     *pkt_pts = (block->i_pts != VLC_TICK_INVALID) ? block->i_pts : block->i_dts;
183
184     vpx_codec_err_t err;
185     err = vpx_codec_decode(ctx, block->p_buffer, block->i_buffer, pkt_pts, 0);
186
187     block_Release(block);
188
189     if (err != VPX_CODEC_OK) {
190         free(pkt_pts);
191         VPX_ERR(dec, ctx, "Failed to decode frame");
192         if (err == VPX_CODEC_UNSUP_BITSTREAM)
193             return VLCDEC_ECRITICAL;
194         else
195             return VLCDEC_SUCCESS;
196     }
197
198     const void *iter = NULL;
199     struct vpx_image *img = vpx_codec_get_frame(ctx, &iter);
200     if (!img) {
201         free(pkt_pts);
202         return VLCDEC_SUCCESS;
203     }
204
205     /* fetches back the PTS */
206     pkt_pts = img->user_priv;
207     vlc_tick_t pts = *pkt_pts;
208     free(pkt_pts);
209
210     dec->fmt_out.i_codec = FindVlcChroma(img);
211
212     if( dec->fmt_out.i_codec == 0 ) {
213         msg_Err(dec, "Unsupported output colorspace %d", img->fmt);
214         return VLCDEC_SUCCESS;
215     }
216
217     video_format_t *v = &dec->fmt_out.video;
218
219     if (img->d_w != v->i_visible_width || img->d_h != v->i_visible_height) {
220         v->i_visible_width = dec->fmt_out.video.i_width = img->d_w;
221         v->i_visible_height = dec->fmt_out.video.i_height = img->d_h;
222     }
223
224     if( !dec->fmt_out.video.i_sar_num || !dec->fmt_out.video.i_sar_den )
225     {
226         dec->fmt_out.video.i_sar_num = 1;
227         dec->fmt_out.video.i_sar_den = 1;
228     }
229
230     v->b_color_range_full = img->range == VPX_CR_FULL_RANGE;
231
232     switch( img->cs )
233     {
234         case VPX_CS_SRGB:
235         case VPX_CS_BT_709:
236             v->space = COLOR_SPACE_BT709;
237             break;
238         case VPX_CS_BT_601:
239         case VPX_CS_SMPTE_170:
240         case VPX_CS_SMPTE_240:
241             v->space = COLOR_SPACE_BT601;
242             break;
243         case VPX_CS_BT_2020:
244             v->space = COLOR_SPACE_BT2020;
245             break;
246         default:
247             break;
248     }
249
250     dec->fmt_out.video.projection_mode = dec->fmt_in.video.projection_mode;
251     dec->fmt_out.video.multiview_mode = dec->fmt_in.video.multiview_mode;
252     dec->fmt_out.video.pose = dec->fmt_in.video.pose;
253
254     if (decoder_UpdateVideoFormat(dec))
255         return VLCDEC_SUCCESS;
256     picture_t *pic = decoder_NewPicture(dec);
257     if (!pic)
258         return VLCDEC_SUCCESS;
259
260     for (int plane = 0; plane < pic->i_planes; plane++ ) {
261         uint8_t *src = img->planes[plane];
262         uint8_t *dst = pic->p[plane].p_pixels;
263         int src_stride = img->stride[plane];
264         int dst_stride = pic->p[plane].i_pitch;
265
266         int size = __MIN( src_stride, dst_stride );
267         for( int line = 0; line < pic->p[plane].i_visible_lines; line++ ) {
268             memcpy( dst, src, size );
269             src += src_stride;
270             dst += dst_stride;
271         }
272     }
273
274     pic->b_progressive = true; /* codec does not support interlacing */
275     pic->date = pts;
276
277     decoder_QueueVideo(dec, pic);
278     return VLCDEC_SUCCESS;
279 }
280
281 /*****************************************************************************
282  * OpenDecoder: probe the decoder
283  *****************************************************************************/
284 static int OpenDecoder(vlc_object_t *p_this)
285 {
286     decoder_t *dec = (decoder_t *)p_this;
287     const struct vpx_codec_iface *iface;
288     int vp_version;
289
290     switch (dec->fmt_in.i_codec)
291     {
292 #ifdef ENABLE_VP8_DECODER
293     case VLC_CODEC_WEBP:
294     case VLC_CODEC_VP8:
295         iface = &vpx_codec_vp8_dx_algo;
296         vp_version = 8;
297         break;
298 #endif
299 #ifdef ENABLE_VP9_DECODER
300     case VLC_CODEC_VP9:
301         iface = &vpx_codec_vp9_dx_algo;
302         vp_version = 9;
303         break;
304 #endif
305     default:
306         return VLC_EGENERIC;
307     }
308
309     decoder_sys_t *sys = malloc(sizeof(*sys));
310     if (!sys)
311         return VLC_ENOMEM;
312     dec->p_sys = sys;
313
314     struct vpx_codec_dec_cfg deccfg = {
315         .threads = __MIN(vlc_GetCPUCount(), 16)
316     };
317
318     msg_Dbg(p_this, "VP%d: using libvpx version %s (build options %s)",
319         vp_version, vpx_codec_version_str(), vpx_codec_build_config());
320
321     if (vpx_codec_dec_init(&sys->ctx, iface, &deccfg, 0) != VPX_CODEC_OK) {
322         VPX_ERR(p_this, &sys->ctx, "Failed to initialize decoder");
323         free(sys);
324         return VLC_EGENERIC;;
325     }
326
327     dec->pf_decode = Decode;
328
329     dec->fmt_out.video.i_width = dec->fmt_in.video.i_width;
330     dec->fmt_out.video.i_height = dec->fmt_in.video.i_height;
331
332     if (dec->fmt_in.video.i_sar_num > 0 && dec->fmt_in.video.i_sar_den > 0) {
333         dec->fmt_out.video.i_sar_num = dec->fmt_in.video.i_sar_num;
334         dec->fmt_out.video.i_sar_den = dec->fmt_in.video.i_sar_den;
335     }
336
337     return VLC_SUCCESS;
338 }
339
340 /*****************************************************************************
341  * CloseDecoder: decoder destruction
342  *****************************************************************************/
343 static void CloseDecoder(vlc_object_t *p_this)
344 {
345     decoder_t *dec = (decoder_t *)p_this;
346     decoder_sys_t *sys = dec->p_sys;
347
348     /* Free our PTS */
349     const void *iter = NULL;
350     for (;;) {
351         struct vpx_image *img = vpx_codec_get_frame(&sys->ctx, &iter);
352         if (!img)
353             break;
354         free(img->user_priv);
355     }
356
357     vpx_codec_destroy(&sys->ctx);
358
359     free(sys);
360 }
361
362 #ifdef ENABLE_SOUT
363
364 /*****************************************************************************
365  * encoder_sys_t: libvpx encoder descriptor
366  *****************************************************************************/
367 typedef struct
368 {
369     struct vpx_codec_ctx ctx;
370     unsigned long quality;
371 } encoder_sys_t;
372
373 /*****************************************************************************
374  * OpenEncoder: probe the encoder
375  *****************************************************************************/
376 static int OpenEncoder(vlc_object_t *p_this)
377 {
378     encoder_t *p_enc = (encoder_t *)p_this;
379     encoder_sys_t *p_sys;
380
381     /* Allocate the memory needed to store the encoder's structure */
382     p_sys = malloc(sizeof(*p_sys));
383     if (p_sys == NULL)
384         return VLC_ENOMEM;
385     p_enc->p_sys = p_sys;
386
387     const struct vpx_codec_iface *iface;
388     int vp_version;
389
390     switch (p_enc->fmt_out.i_codec)
391     {
392 #ifdef ENABLE_VP8_ENCODER
393     case VLC_CODEC_VP8:
394         iface = &vpx_codec_vp8_cx_algo;
395         vp_version = 8;
396         break;
397 #endif
398 #ifdef ENABLE_VP9_ENCODER
399     case VLC_CODEC_VP9:
400         iface = &vpx_codec_vp9_cx_algo;
401         vp_version = 9;
402         break;
403 #endif
404     default:
405         free(p_sys);
406         return VLC_EGENERIC;
407     }
408
409     struct vpx_codec_enc_cfg enccfg = {0};
410     vpx_codec_enc_config_default(iface, &enccfg, 0);
411     enccfg.g_threads = __MIN(vlc_GetCPUCount(), 4);
412     enccfg.g_w = p_enc->fmt_in.video.i_visible_width;
413     enccfg.g_h = p_enc->fmt_in.video.i_visible_height;
414
415     msg_Dbg(p_this, "VP%d: using libvpx version %s (build options %s)",
416         vp_version, vpx_codec_version_str(), vpx_codec_build_config());
417
418     struct vpx_codec_ctx *ctx = &p_sys->ctx;
419     if (vpx_codec_enc_init(ctx, iface, &enccfg, 0) != VPX_CODEC_OK) {
420         VPX_ERR(p_this, ctx, "Failed to initialize encoder");
421         free(p_sys);
422         return VLC_EGENERIC;
423     }
424
425     p_enc->pf_encode_video = Encode;
426     p_enc->fmt_in.i_codec = VLC_CODEC_I420;
427     config_ChainParse(p_enc, ENC_CFG_PREFIX, ppsz_sout_options, p_enc->p_cfg);
428
429     /* Deadline (in ms) to spend in encoder */
430     switch (var_GetInteger(p_enc, ENC_CFG_PREFIX "quality-mode")) {
431         case 1:
432             p_sys->quality = VPX_DL_REALTIME;
433             break;
434         case 2:
435             p_sys->quality = VPX_DL_BEST_QUALITY;
436             break;
437         default:
438             p_sys->quality = VPX_DL_GOOD_QUALITY;
439             break;
440     }
441
442     return VLC_SUCCESS;
443 }
444
445 /****************************************************************************
446  * Encode: the whole thing
447  ****************************************************************************/
448 static block_t *Encode(encoder_t *p_enc, picture_t *p_pict)
449 {
450     encoder_sys_t *p_sys = p_enc->p_sys;
451     struct vpx_codec_ctx *ctx = &p_sys->ctx;
452
453     if (!p_pict) return NULL;
454
455     vpx_image_t img = {0};
456     unsigned i_w = p_enc->fmt_in.video.i_visible_width;
457     unsigned i_h = p_enc->fmt_in.video.i_visible_height;
458
459     /* Create and initialize the vpx_image */
460     if (!vpx_img_wrap(&img, VPX_IMG_FMT_I420, i_w, i_h, 32, p_pict->p[0].p_pixels)) {
461         VPX_ERR(p_enc, ctx, "Failed to wrap image");
462         return NULL;
463     }
464
465     /* Correct chroma plane offsets. */
466     for (int plane = 1; plane < p_pict->i_planes; plane++) {
467         img.planes[plane] = p_pict->p[plane].p_pixels;
468         img.stride[plane] = p_pict->p[plane].i_pitch;
469     }
470
471     int flags = 0;
472
473     vpx_codec_err_t res = vpx_codec_encode(ctx, &img, p_pict->date, 1,
474      flags, p_sys->quality);
475     if (res != VPX_CODEC_OK) {
476         VPX_ERR(p_enc, ctx, "Failed to encode frame");
477         vpx_img_free(&img);
478         return NULL;
479     }
480
481     const vpx_codec_cx_pkt_t *pkt = NULL;
482     vpx_codec_iter_t iter = NULL;
483     block_t *p_out = NULL;
484     while ((pkt = vpx_codec_get_cx_data(ctx, &iter)) != NULL)
485     {
486         if (pkt->kind == VPX_CODEC_CX_FRAME_PKT)
487         {
488             int keyframe = pkt->data.frame.flags & VPX_FRAME_IS_KEY;
489             block_t *p_block = block_Alloc(pkt->data.frame.sz);
490             if (unlikely(p_block == NULL))
491             {
492                 block_ChainRelease(p_out);
493                 p_out = NULL;
494                 break;
495             }
496
497             memcpy(p_block->p_buffer, pkt->data.frame.buf, pkt->data.frame.sz);
498             p_block->i_dts = p_block->i_pts = pkt->data.frame.pts;
499             if (keyframe)
500                 p_block->i_flags |= BLOCK_FLAG_TYPE_I;
501             block_ChainAppend(&p_out, p_block);
502         }
503     }
504     vpx_img_free(&img);
505     return p_out;
506 }
507
508 /*****************************************************************************
509  * CloseEncoder: encoder destruction
510  *****************************************************************************/
511 static void CloseEncoder(vlc_object_t *p_this)
512 {
513     encoder_t *p_enc = (encoder_t *)p_this;
514     encoder_sys_t *p_sys = p_enc->p_sys;
515     if (vpx_codec_destroy(&p_sys->ctx))
516         VPX_ERR(p_this, &p_sys->ctx, "Failed to destroy codec");
517     free(p_sys);
518 }
519
520 #endif  /* ENABLE_SOUT */