modules/packetizer/hevc.c

   1 /*****************************************************************************
   2  * hevc.c: h.265/hevc video packetizer
   3  *****************************************************************************
   4  * Copyright (C) 2014 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Denis Charmet <typx@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17  * GNU Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <vlc_common.h>
  33 #include <vlc_plugin.h>
  34 #include <vlc_codec.h>
  35 #include <vlc_block.h>
  36 #include <vlc_bits.h>
  37
  38 #include <vlc_block_helper.h>
  39 #include "packetizer_helper.h"
  40 #include "startcode_helper.h"
  41 #include "hevc_nal.h"
  42 #include "hxxx_nal.h"
  43 #include "hxxx_sei.h"
  44 #include "hxxx_common.h"
  45
  46 #include <limits.h>
  47
  48 /*****************************************************************************
  49  * Module descriptor
  50  *****************************************************************************/
  51 static int  Open (vlc_object_t *);
  52 static void Close(vlc_object_t *);
  53
  54 vlc_module_begin ()
  55     set_category(CAT_SOUT)
  56     set_subcategory(SUBCAT_SOUT_PACKETIZER)
  57     set_description(N_("HEVC/H.265 video packetizer"))
  58     set_capability("packetizer", 50)
  59     set_callbacks(Open, Close)
  60 vlc_module_end ()
  61
  62
  63 /****************************************************************************
  64  * Local prototypes
  65  ****************************************************************************/
  66 static block_t *PacketizeAnnexB(decoder_t *, block_t **);
  67 static block_t *PacketizeHVC1(decoder_t *, block_t **);
  68 static void PacketizeFlush( decoder_t * );
  69 static void PacketizeReset(void *p_private, bool b_broken);
  70 static block_t *PacketizeParse(void *p_private, bool *pb_ts_used, block_t *);
  71 static block_t *ParseNALBlock(decoder_t *, bool *pb_ts_used, block_t *);
  72 static int PacketizeValidate(void *p_private, block_t *);
  73 static bool ParseSEICallback( const hxxx_sei_data_t *, void * );
  74 static block_t *GetCc( decoder_t *, decoder_cc_desc_t * );
  75
  76 typedef struct
  77 {
  78     /* */
  79     packetizer_t packetizer;
  80
  81     struct
  82     {
  83         block_t *p_chain;
  84         block_t **pp_chain_last;
  85     } frame, pre, post;
  86
  87     uint8_t  i_nal_length_size;
  88
  89     struct
  90     {
  91         block_t *p_nal;
  92         void *p_decoded;
  93     } rg_vps[HEVC_VPS_ID_MAX + 1],
  94       rg_sps[HEVC_SPS_ID_MAX + 1],
  95       rg_pps[HEVC_PPS_ID_MAX + 1];
  96
  97     const hevc_video_parameter_set_t    *p_active_vps;
  98     const hevc_sequence_parameter_set_t *p_active_sps;
  99     const hevc_picture_parameter_set_t  *p_active_pps;
 100     hevc_sei_pic_timing_t *p_timing;
 101     bool b_init_sequence_complete;
 102
 103     date_t dts;
 104     vlc_tick_t pts;
 105     bool b_need_ts;
 106
 107     /* */
 108     cc_storage_t *p_ccs;
 109 } decoder_sys_t;
 110
 111 #define BLOCK_FLAG_DROP (1 << BLOCK_FLAG_PRIVATE_SHIFT)
 112
 113 static const uint8_t p_hevc_startcode[3] = {0x00, 0x00, 0x01};
 114 /****************************************************************************
 115  * Helpers
 116  ****************************************************************************/
 117 static inline void InitQueue( block_t **pp_head, block_t ***ppp_tail )
 118 {
 119     *pp_head = NULL;
 120     *ppp_tail = pp_head;
 121 }
 122 #define INITQ(name) InitQueue(&p_sys->name.p_chain, &p_sys->name.pp_chain_last)
 123
 124 static block_t * OutputQueues(decoder_sys_t *p_sys, bool b_valid)
 125 {
 126     block_t *p_output = NULL;
 127     block_t **pp_output_last = &p_output;
 128     uint32_t i_flags = 0; /* Because block_ChainGather does not merge flags or times */
 129
 130     if(p_sys->pre.p_chain)
 131     {
 132         i_flags |= p_sys->pre.p_chain->i_flags;
 133         block_ChainLastAppend(&pp_output_last, p_sys->pre.p_chain);
 134         INITQ(pre);
 135     }
 136
 137     if(p_sys->frame.p_chain)
 138     {
 139         i_flags |= p_sys->frame.p_chain->i_flags;
 140         block_ChainLastAppend(&pp_output_last, p_sys->frame.p_chain);
 141         p_output->i_dts = date_Get(&p_sys->dts);
 142         p_output->i_pts = p_sys->pts;
 143         INITQ(frame);
 144     }
 145
 146     if(p_sys->post.p_chain)
 147     {
 148         i_flags |= p_sys->post.p_chain->i_flags;
 149         block_ChainLastAppend(&pp_output_last, p_sys->post.p_chain);
 150         INITQ(post);
 151     }
 152
 153     if(p_output)
 154     {
 155         p_output->i_flags |= i_flags;
 156         if(!b_valid)
 157             p_output->i_flags |= BLOCK_FLAG_DROP;
 158     }
 159
 160     return p_output;
 161 }
 162
 163
 164 /*****************************************************************************
 165  * Open
 166  *****************************************************************************/
 167 static int Open(vlc_object_t *p_this)
 168 {
 169     decoder_t     *p_dec = (decoder_t*)p_this;
 170     decoder_sys_t *p_sys;
 171
 172     if (p_dec->fmt_in.i_codec != VLC_CODEC_HEVC)
 173         return VLC_EGENERIC;
 174
 175     p_dec->p_sys = p_sys = calloc(1, sizeof(decoder_sys_t));
 176     if (!p_dec->p_sys)
 177         return VLC_ENOMEM;
 178
 179     p_sys->p_ccs = cc_storage_new();
 180     if(unlikely(!p_sys->p_ccs))
 181     {
 182         free(p_dec->p_sys);
 183         return VLC_ENOMEM;
 184     }
 185
 186     INITQ(pre);
 187     INITQ(frame);
 188     INITQ(post);
 189
 190     packetizer_Init(&p_sys->packetizer,
 191                     p_hevc_startcode, sizeof(p_hevc_startcode), startcode_FindAnnexB,
 192                     p_hevc_startcode, 1, 5,
 193                     PacketizeReset, PacketizeParse, PacketizeValidate, p_dec);
 194
 195     /* Copy properties */
 196     es_format_Copy(&p_dec->fmt_out, &p_dec->fmt_in);
 197     p_dec->fmt_out.b_packetized = true;
 198
 199     /* Init timings */
 200     if( p_dec->fmt_in.video.i_frame_rate_base &&
 201         p_dec->fmt_in.video.i_frame_rate &&
 202         p_dec->fmt_in.video.i_frame_rate <= UINT_MAX / 2 )
 203         date_Init( &p_sys->dts, p_dec->fmt_in.video.i_frame_rate * 2,
 204                                 p_dec->fmt_in.video.i_frame_rate_base );
 205     else
 206         date_Init( &p_sys->dts, 2 * 30000, 1001 );
 207     p_sys->pts = VLC_TICK_INVALID;
 208     p_sys->b_need_ts = true;
 209
 210     /* Set callbacks */
 211     const uint8_t *p_extra = p_dec->fmt_in.p_extra;
 212     const size_t i_extra = p_dec->fmt_in.i_extra;
 213     /* Check if we have hvcC as extradata */
 214     if(hevc_ishvcC(p_extra, i_extra))
 215     {
 216         p_dec->pf_packetize = PacketizeHVC1;
 217
 218         /* Clear hvcC/HVC1 extra, to be replaced with AnnexB */
 219         free(p_dec->fmt_out.p_extra);
 220         p_dec->fmt_out.i_extra = 0;
 221
 222         size_t i_new_extra = 0;
 223         p_dec->fmt_out.p_extra =
 224                 hevc_hvcC_to_AnnexB_NAL(p_extra, i_extra,
 225                                         &i_new_extra, &p_sys->i_nal_length_size);
 226         if(p_dec->fmt_out.p_extra)
 227             p_dec->fmt_out.i_extra = i_new_extra;
 228     }
 229     else
 230     {
 231         p_dec->pf_packetize = PacketizeAnnexB;
 232     }
 233     p_dec->pf_flush = PacketizeFlush;
 234     p_dec->pf_get_cc = GetCc;
 235
 236     if(p_dec->fmt_out.i_extra)
 237     {
 238         /* Feed with AnnexB VPS/SPS/PPS/SEI extradata */
 239         packetizer_Header(&p_sys->packetizer,
 240                           p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra);
 241     }
 242
 243     return VLC_SUCCESS;
 244 }
 245
 246 /*****************************************************************************
 247  * Close
 248  *****************************************************************************/
 249 static void Close(vlc_object_t *p_this)
 250 {
 251     decoder_t *p_dec = (decoder_t*)p_this;
 252     decoder_sys_t *p_sys = p_dec->p_sys;
 253     packetizer_Clean(&p_sys->packetizer);
 254
 255     block_ChainRelease(p_sys->frame.p_chain);
 256     block_ChainRelease(p_sys->pre.p_chain);
 257     block_ChainRelease(p_sys->post.p_chain);
 258
 259     for(unsigned i=0;i<=HEVC_PPS_ID_MAX; i++)
 260     {
 261         if(p_sys->rg_pps[i].p_decoded)
 262             hevc_rbsp_release_pps(p_sys->rg_pps[i].p_decoded);
 263         if(p_sys->rg_pps[i].p_nal)
 264             block_Release(p_sys->rg_pps[i].p_nal);
 265     }
 266
 267     for(unsigned i=0;i<=HEVC_SPS_ID_MAX; i++)
 268     {
 269         if(p_sys->rg_sps[i].p_decoded)
 270             hevc_rbsp_release_sps(p_sys->rg_sps[i].p_decoded);
 271         if(p_sys->rg_sps[i].p_nal)
 272             block_Release(p_sys->rg_sps[i].p_nal);
 273     }
 274
 275     for(unsigned i=0;i<=HEVC_VPS_ID_MAX; i++)
 276     {
 277         if(p_sys->rg_vps[i].p_decoded)
 278             hevc_rbsp_release_vps(p_sys->rg_vps[i].p_decoded);
 279         if(p_sys->rg_vps[i].p_nal)
 280             block_Release(p_sys->rg_vps[i].p_nal);
 281     }
 282
 283     hevc_release_sei_pic_timing( p_sys->p_timing );
 284
 285     cc_storage_delete( p_sys->p_ccs );
 286
 287     free(p_sys);
 288 }
 289
 290 /****************************************************************************
 291  * Packetize
 292  ****************************************************************************/
 293 static block_t *PacketizeHVC1(decoder_t *p_dec, block_t **pp_block)
 294 {
 295     decoder_sys_t *p_sys = p_dec->p_sys;
 296
 297     return PacketizeXXC1( p_dec, p_sys->i_nal_length_size,
 298                           pp_block, ParseNALBlock );
 299 }
 300
 301 static block_t *PacketizeAnnexB(decoder_t *p_dec, block_t **pp_block)
 302 {
 303     decoder_sys_t *p_sys = p_dec->p_sys;
 304
 305     return packetizer_Packetize(&p_sys->packetizer, pp_block);
 306 }
 307
 308 static void PacketizeFlush( decoder_t *p_dec )
 309 {
 310     decoder_sys_t *p_sys = p_dec->p_sys;
 311
 312     packetizer_Flush( &p_sys->packetizer );
 313 }
 314
 315 /*****************************************************************************
 316  * GetCc:
 317  *****************************************************************************/
 318 static block_t *GetCc( decoder_t *p_dec, decoder_cc_desc_t *p_desc )
 319 {
 320     decoder_sys_t *p_sys = p_dec->p_sys;
 321     return cc_storage_get_current( p_sys->p_ccs, p_desc );
 322 }
 323
 324 /****************************************************************************
 325  * Packetizer Helpers
 326  ****************************************************************************/
 327 static void PacketizeReset(void *p_private, bool b_broken)
 328 {
 329     VLC_UNUSED(b_broken);
 330
 331     decoder_t *p_dec = p_private;
 332     decoder_sys_t *p_sys = p_dec->p_sys;
 333
 334     block_t *p_out = OutputQueues(p_sys, false);
 335     if(p_out)
 336         block_ChainRelease(p_out);
 337
 338     p_sys->b_init_sequence_complete = false;
 339     p_sys->b_need_ts = true;
 340     date_Set(&p_sys->dts, VLC_TICK_INVALID);
 341 }
 342
 343 static bool InsertXPS(decoder_t *p_dec, uint8_t i_nal_type, uint8_t i_id,
 344                       const block_t *p_nalb)
 345 {
 346     decoder_sys_t *p_sys = p_dec->p_sys;
 347     void **pp_decoded;
 348     void **pp_active;
 349     block_t **pp_nal;
 350
 351     switch(i_nal_type)
 352     {
 353         case HEVC_NAL_VPS:
 354             if(i_id > HEVC_VPS_ID_MAX)
 355                 return false;
 356             pp_decoded = &p_sys->rg_vps[i_id].p_decoded;
 357             pp_nal = &p_sys->rg_vps[i_id].p_nal;
 358             pp_active = (void**)&p_sys->p_active_vps;
 359             break;
 360         case HEVC_NAL_SPS:
 361             if(i_id > HEVC_SPS_ID_MAX)
 362                 return false;
 363             pp_decoded = &p_sys->rg_sps[i_id].p_decoded;
 364             pp_nal = &p_sys->rg_sps[i_id].p_nal;
 365             pp_active = (void**)&p_sys->p_active_sps;
 366             break;
 367         case HEVC_NAL_PPS:
 368             if(i_id > HEVC_PPS_ID_MAX)
 369                 return false;
 370             pp_decoded = &p_sys->rg_pps[i_id].p_decoded;
 371             pp_nal = &p_sys->rg_pps[i_id].p_nal;
 372             pp_active = (void**)&p_sys->p_active_pps;
 373             break;
 374         default:
 375             return false;
 376     }
 377
 378     /* Check if we really need to re-decode/replace */
 379     if(*pp_nal)
 380     {
 381         const uint8_t *p_stored = (*pp_nal)->p_buffer;
 382         size_t i_stored = (*pp_nal)->i_buffer;
 383         hxxx_strip_AnnexB_startcode(&p_stored, &i_stored);
 384         const uint8_t *p_new = p_nalb->p_buffer;
 385         size_t i_new = p_nalb->i_buffer;
 386         hxxx_strip_AnnexB_startcode(&p_new, &i_new);
 387         if(i_stored == i_new && !memcmp(p_stored, p_new, i_new))
 388             return true;
 389     }
 390
 391     /* Free associated decoded version */
 392     if(*pp_decoded)
 393     {
 394         switch(i_nal_type)
 395         {
 396             case HEVC_NAL_VPS:
 397                 hevc_rbsp_release_vps(*pp_decoded);
 398                 break;
 399             case HEVC_NAL_SPS:
 400                 hevc_rbsp_release_sps(*pp_decoded);
 401                 break;
 402             case HEVC_NAL_PPS:
 403                 hevc_rbsp_release_pps(*pp_decoded);
 404                 break;
 405         }
 406         if(*pp_active == *pp_decoded)
 407             *pp_active = NULL;
 408         else
 409             pp_active = NULL; /* don't change pointer */
 410         *pp_decoded = NULL;
 411     }
 412     else pp_active = NULL;
 413
 414     /* Free raw stored version */
 415     if(*pp_nal)
 416     {
 417         block_Release(*pp_nal);
 418         *pp_nal = NULL;
 419     }
 420
 421     const uint8_t *p_buffer = p_nalb->p_buffer;
 422     size_t i_buffer = p_nalb->i_buffer;
 423     if( hxxx_strip_AnnexB_startcode( &p_buffer, &i_buffer ) )
 424     {
 425         /* Create decoded entries */
 426         switch(i_nal_type)
 427         {
 428             case HEVC_NAL_SPS:
 429                 *pp_decoded = hevc_decode_sps(p_buffer, i_buffer, true);
 430                 if(!*pp_decoded)
 431                 {
 432                     msg_Err(p_dec, "Failed decoding SPS id %d", i_id);
 433                     return false;
 434                 }
 435                 break;
 436             case HEVC_NAL_PPS:
 437                 *pp_decoded = hevc_decode_pps(p_buffer, i_buffer, true);
 438                 if(!*pp_decoded)
 439                 {
 440                     msg_Err(p_dec, "Failed decoding PPS id %d", i_id);
 441                     return false;
 442                 }
 443                 break;
 444             case HEVC_NAL_VPS:
 445                 *pp_decoded = hevc_decode_vps(p_buffer, i_buffer, true);
 446                 if(!*pp_decoded)
 447                 {
 448                     msg_Err(p_dec, "Failed decoding VPS id %d", i_id);
 449                     return false;
 450                 }
 451                 break;
 452         }
 453
 454         if(*pp_decoded && pp_active) /* restore active by id */
 455             *pp_active = *pp_decoded;
 456
 457         *pp_nal = block_Duplicate((block_t *)p_nalb);
 458
 459         return true;
 460     }
 461
 462     return false;
 463 }
 464
 465 static bool XPSReady(decoder_sys_t *p_sys)
 466 {
 467     for(unsigned i=0;i<=HEVC_PPS_ID_MAX; i++)
 468     {
 469         const hevc_picture_parameter_set_t *p_pps = p_sys->rg_pps[i].p_decoded;
 470         if (p_pps)
 471         {
 472             uint8_t id_sps = hevc_get_pps_sps_id(p_pps);
 473             const hevc_sequence_parameter_set_t *p_sps = p_sys->rg_sps[id_sps].p_decoded;
 474             if(p_sps)
 475             {
 476                 uint8_t id_vps = hevc_get_sps_vps_id(p_sps);
 477                 if(p_sys->rg_vps[id_vps].p_decoded)
 478                     return true;
 479             }
 480         }
 481     }
 482     return false;
 483 }
 484
 485 static void AppendAsAnnexB(const block_t *p_block,
 486                            uint8_t **pp_dst, size_t *pi_dst)
 487 {
 488     if(SIZE_MAX - p_block->i_buffer < *pi_dst )
 489         return;
 490
 491     size_t i_realloc = p_block->i_buffer + *pi_dst;
 492     uint8_t *p_realloc = realloc(*pp_dst, i_realloc);
 493     if(p_realloc)
 494     {
 495         memcpy(&p_realloc[*pi_dst], p_block->p_buffer, p_block->i_buffer);
 496         *pi_dst = i_realloc;
 497         *pp_dst = p_realloc;
 498     }
 499 }
 500
 501 #define APPENDIF(idmax, set, rg, b) \
 502     for(size_t i=0; i<=idmax; i++)\
 503     {\
 504         if(((set != rg[i].p_decoded) == !b) && rg[i].p_nal)\
 505         {\
 506             AppendAsAnnexB(rg[i].p_nal, &p_data, &i_data);\
 507             break;\
 508         }\
 509     }
 510
 511 static void SetsToAnnexB(decoder_sys_t *p_sys,
 512                          const hevc_picture_parameter_set_t *p_pps,
 513                          const hevc_sequence_parameter_set_t *p_sps,
 514                          const hevc_video_parameter_set_t *p_vps,
 515                          uint8_t **pp_out, int *pi_out)
 516 {
 517     uint8_t *p_data = NULL;
 518     size_t i_data = 0;
 519
 520     APPENDIF(HEVC_VPS_ID_MAX, p_vps, p_sys->rg_vps, true);
 521     APPENDIF(HEVC_VPS_ID_MAX, p_vps, p_sys->rg_vps, false);
 522     APPENDIF(HEVC_SPS_ID_MAX, p_sps, p_sys->rg_sps, true);
 523     APPENDIF(HEVC_SPS_ID_MAX, p_sps, p_sys->rg_sps, false);
 524     APPENDIF(HEVC_PPS_ID_MAX, p_pps, p_sys->rg_pps, true);
 525     APPENDIF(HEVC_PPS_ID_MAX, p_pps, p_sys->rg_pps, false);
 526
 527     /* because we copy to i_extra :/ */
 528     if(i_data <= INT_MAX)
 529     {
 530         *pp_out = p_data;
 531         *pi_out = i_data;
 532     }
 533     else free(p_data);
 534 }
 535
 536 static void ActivateSets(decoder_t *p_dec,
 537                          const hevc_picture_parameter_set_t *p_pps,
 538                          const hevc_sequence_parameter_set_t *p_sps,
 539                          const hevc_video_parameter_set_t *p_vps)
 540 {
 541     decoder_sys_t *p_sys = p_dec->p_sys;
 542     p_sys->p_active_pps = p_pps;
 543     p_sys->p_active_sps = p_sps;
 544     p_sys->p_active_vps = p_vps;
 545     if(p_sps)
 546     {
 547         if(!p_dec->fmt_in.video.i_frame_rate || !p_dec->fmt_in.video.i_frame_rate_base)
 548         {
 549             unsigned num, den;
 550             if(hevc_get_frame_rate( p_sps, p_vps, &num, &den ))
 551             {
 552                 p_dec->fmt_out.video.i_frame_rate = num;
 553                 p_dec->fmt_out.video.i_frame_rate_base = den;
 554                 if(p_sys->dts.i_divider_den != den &&
 555                    p_sys->dts.i_divider_num != 2 * num &&
 556                    num <= UINT_MAX / 2)
 557                     date_Change(&p_sys->dts, 2 * num, den);
 558             }
 559         }
 560
 561         if(p_dec->fmt_in.video.primaries == COLOR_PRIMARIES_UNDEF)
 562         {
 563             (void) hevc_get_colorimetry( p_sps,
 564                                          &p_dec->fmt_out.video.primaries,
 565                                          &p_dec->fmt_out.video.transfer,
 566                                          &p_dec->fmt_out.video.space,
 567                                          &p_dec->fmt_out.video.b_color_range_full);
 568         }
 569
 570         unsigned sizes[4];
 571         if( hevc_get_picture_size( p_sps, &sizes[0], &sizes[1],
 572                                           &sizes[2], &sizes[3] ) )
 573         {
 574             p_dec->fmt_out.video.i_width = sizes[0];
 575             p_dec->fmt_out.video.i_height = sizes[1];
 576             if(p_dec->fmt_in.video.i_visible_width == 0)
 577             {
 578                 p_dec->fmt_out.video.i_visible_width = sizes[2];
 579                 p_dec->fmt_out.video.i_visible_height = sizes[3];
 580             }
 581         }
 582
 583         if(p_dec->fmt_in.i_profile == -1)
 584         {
 585             uint8_t i_profile, i_level;
 586             if( hevc_get_sps_profile_tier_level( p_sps, &i_profile, &i_level ) )
 587             {
 588                 p_dec->fmt_out.i_profile = i_profile;
 589                 p_dec->fmt_out.i_level = i_level;
 590             }
 591         }
 592
 593         if(p_dec->fmt_out.i_extra == 0 && p_vps && p_pps)
 594             SetsToAnnexB(p_sys, p_pps, p_sps, p_vps,
 595                          (uint8_t **)&p_dec->fmt_out.p_extra, &p_dec->fmt_out.i_extra);
 596     }
 597 }
 598
 599 static void GetXPSSet(uint8_t i_pps_id, void *priv,
 600                       hevc_picture_parameter_set_t **pp_pps,
 601                       hevc_sequence_parameter_set_t **pp_sps,
 602                       hevc_video_parameter_set_t **pp_vps)
 603 {
 604     decoder_sys_t *p_sys = priv;
 605     *pp_sps = NULL;
 606     *pp_vps = NULL;
 607     if((*pp_pps = p_sys->rg_pps[i_pps_id].p_decoded))
 608         if((*pp_sps = p_sys->rg_sps[hevc_get_pps_sps_id(*pp_pps)].p_decoded))
 609             *pp_vps = p_sys->rg_vps[hevc_get_sps_vps_id(*pp_sps)].p_decoded;
 610 }
 611
 612 static void ParseStoredSEI( decoder_t *p_dec )
 613 {
 614     decoder_sys_t *p_sys = p_dec->p_sys;
 615
 616     for( block_t *p_nal = p_sys->pre.p_chain;
 617                   p_nal; p_nal = p_nal->p_next )
 618     {
 619         if( p_nal->i_buffer < 5 )
 620             continue;
 621
 622         if( hevc_getNALType(&p_nal->p_buffer[4]) == HEVC_NAL_PREF_SEI )
 623         {
 624             HxxxParse_AnnexB_SEI( p_nal->p_buffer, p_nal->i_buffer,
 625                                   2 /* nal header */, ParseSEICallback, p_dec );
 626         }
 627     }
 628 }
 629
 630 static block_t *ParseVCL(decoder_t *p_dec, uint8_t i_nal_type, block_t *p_frag)
 631 {
 632     decoder_sys_t *p_sys = p_dec->p_sys;
 633     block_t *p_outputchain = NULL;
 634
 635     const uint8_t *p_buffer = p_frag->p_buffer;
 636     size_t i_buffer = p_frag->i_buffer;
 637
 638     if(unlikely(!hxxx_strip_AnnexB_startcode(&p_buffer, &i_buffer) || i_buffer < 3))
 639     {
 640         block_ChainLastAppend(&p_sys->frame.pp_chain_last, p_frag); /* might be corrupted */
 641         return NULL;
 642     }
 643
 644     const uint8_t i_layer = hevc_getNALLayer( p_buffer );
 645     bool b_first_slice_in_pic = p_buffer[2] & 0x80;
 646     if (b_first_slice_in_pic)
 647     {
 648         if(p_sys->frame.p_chain)
 649         {
 650             /* Starting new frame: return previous frame data for output */
 651             p_outputchain = OutputQueues(p_sys, p_sys->b_init_sequence_complete);
 652         }
 653
 654         hevc_slice_segment_header_t *p_sli = hevc_decode_slice_header(p_buffer, i_buffer, true,
 655                                                                       GetXPSSet, p_sys);
 656         if(p_sli && i_layer == 0)
 657         {
 658             hevc_sequence_parameter_set_t *p_sps;
 659             hevc_picture_parameter_set_t *p_pps;
 660             hevc_video_parameter_set_t *p_vps;
 661             GetXPSSet(hevc_get_slice_pps_id(p_sli), p_sys, &p_pps, &p_sps, &p_vps);
 662             ActivateSets(p_dec, p_pps, p_sps, p_vps);
 663         }
 664
 665         ParseStoredSEI( p_dec );
 666
 667         switch(i_nal_type)
 668         {
 669             case HEVC_NAL_BLA_W_LP:
 670             case HEVC_NAL_BLA_W_RADL:
 671             case HEVC_NAL_BLA_N_LP:
 672             case HEVC_NAL_IDR_W_RADL:
 673             case HEVC_NAL_IDR_N_LP:
 674             case HEVC_NAL_CRA:
 675                 p_frag->i_flags |= BLOCK_FLAG_TYPE_I;
 676                 break;
 677
 678             default:
 679             {
 680                 if(p_sli)
 681                 {
 682                     enum hevc_slice_type_e type;
 683                     if(hevc_get_slice_type( p_sli, &type ))
 684                     {
 685                         if( type == HEVC_SLICE_TYPE_P )
 686                             p_frag->i_flags |= BLOCK_FLAG_TYPE_P;
 687                         else
 688                             p_frag->i_flags |= BLOCK_FLAG_TYPE_B;
 689                     }
 690                 }
 691                 else p_frag->i_flags |= BLOCK_FLAG_TYPE_B;
 692             }
 693             break;
 694         }
 695
 696         if(p_sli)
 697             hevc_rbsp_release_slice_header(p_sli);
 698     }
 699
 700     if(!p_sys->b_init_sequence_complete && i_layer == 0 &&
 701        (p_frag->i_flags & BLOCK_FLAG_TYPE_I) && XPSReady(p_sys))
 702     {
 703         p_sys->b_init_sequence_complete = true;
 704     }
 705
 706     if( !p_sys->b_init_sequence_complete )
 707         cc_storage_reset( p_sys->p_ccs );
 708
 709     block_ChainLastAppend(&p_sys->frame.pp_chain_last, p_frag);
 710
 711     return p_outputchain;
 712 }
 713
 714 static block_t * ParseAUHead(decoder_t *p_dec, uint8_t i_nal_type, block_t *p_nalb)
 715 {
 716     decoder_sys_t *p_sys = p_dec->p_sys;
 717     block_t *p_ret = NULL;
 718
 719     if(p_sys->post.p_chain || p_sys->frame.p_chain)
 720         p_ret = OutputQueues(p_sys, p_sys->b_init_sequence_complete);
 721
 722     switch(i_nal_type)
 723     {
 724         case HEVC_NAL_AUD:
 725             if(!p_ret && p_sys->pre.p_chain)
 726                 p_ret = OutputQueues(p_sys, p_sys->b_init_sequence_complete);
 727             break;
 728
 729         case HEVC_NAL_VPS:
 730         case HEVC_NAL_SPS:
 731         case HEVC_NAL_PPS:
 732         {
 733             uint8_t i_id;
 734             const uint8_t *p_xps = p_nalb->p_buffer;
 735             size_t i_xps = p_nalb->i_buffer;
 736             if(hxxx_strip_AnnexB_startcode(&p_xps, &i_xps) &&
 737                hevc_get_xps_id(p_nalb->p_buffer, p_nalb->i_buffer, &i_id))
 738                 InsertXPS(p_dec, i_nal_type, i_id, p_nalb);
 739             break;
 740         }
 741
 742         case HEVC_NAL_PREF_SEI:
 743             /* stored an parsed later when we get sps & frame */
 744         default:
 745             break;
 746     }
 747
 748     block_ChainLastAppend(&p_sys->pre.pp_chain_last, p_nalb);
 749
 750     return p_ret;
 751 }
 752
 753 static block_t * ParseAUTail(decoder_t *p_dec, uint8_t i_nal_type, block_t *p_nalb)
 754 {
 755     decoder_sys_t *p_sys = p_dec->p_sys;
 756     block_t *p_ret = NULL;
 757
 758     block_ChainLastAppend(&p_sys->post.pp_chain_last, p_nalb);
 759
 760     switch(i_nal_type)
 761     {
 762         case HEVC_NAL_EOS:
 763         case HEVC_NAL_EOB:
 764             p_ret = OutputQueues(p_sys, p_sys->b_init_sequence_complete);
 765             if( p_ret )
 766                 p_ret->i_flags |= BLOCK_FLAG_END_OF_SEQUENCE;
 767             break;
 768
 769         case HEVC_NAL_SUFF_SEI:
 770             HxxxParse_AnnexB_SEI( p_nalb->p_buffer, p_nalb->i_buffer,
 771                                   2 /* nal header */, ParseSEICallback, p_dec );
 772             break;
 773     }
 774
 775     if(!p_ret && p_sys->frame.p_chain == NULL)
 776         p_ret = OutputQueues(p_sys, false);
 777
 778     return p_ret;
 779 }
 780
 781 static block_t * ParseNonVCL(decoder_t *p_dec, uint8_t i_nal_type, block_t *p_nalb)
 782 {
 783     block_t *p_ret = NULL;
 784
 785     if ( (i_nal_type >= HEVC_NAL_VPS        && i_nal_type <= HEVC_NAL_AUD) ||
 786           i_nal_type == HEVC_NAL_PREF_SEI ||
 787          (i_nal_type >= HEVC_NAL_RSV_NVCL41 && i_nal_type <= HEVC_NAL_RSV_NVCL44) ||
 788          (i_nal_type >= HEVC_NAL_UNSPEC48   && i_nal_type <= HEVC_NAL_UNSPEC55) )
 789     {
 790         p_ret = ParseAUHead(p_dec, i_nal_type, p_nalb);
 791     }
 792     else
 793     {
 794         p_ret = ParseAUTail(p_dec, i_nal_type, p_nalb);
 795     }
 796
 797     return p_ret;
 798 }
 799
 800 static block_t *GatherAndValidateChain(block_t *p_outputchain)
 801 {
 802     block_t *p_output = NULL;
 803
 804     if(p_outputchain)
 805     {
 806         if(p_outputchain->i_flags & BLOCK_FLAG_DROP)
 807             p_output = p_outputchain; /* Avoid useless gather */
 808         else
 809             p_output = block_ChainGather(p_outputchain);
 810     }
 811
 812     if(p_output && (p_output->i_flags & BLOCK_FLAG_DROP))
 813     {
 814         block_ChainRelease(p_output); /* Chain! see above */
 815         p_output = NULL;
 816     }
 817
 818     return p_output;
 819 }
 820
 821 static void SetOutputBlockProperties(decoder_t *p_dec, block_t *p_output)
 822 {
 823     decoder_sys_t *p_sys = p_dec->p_sys;
 824     /* Set frame duration */
 825     if(p_sys->p_active_sps)
 826     {
 827         uint8_t i_num_clock_ts = hevc_get_num_clock_ts(p_sys->p_active_sps,
 828                                                        p_sys->p_timing);
 829         const vlc_tick_t i_start = date_Get(&p_sys->dts);
 830         if( i_start != VLC_TICK_INVALID )
 831         {
 832             date_Increment(&p_sys->dts, i_num_clock_ts);
 833             p_output->i_length = date_Get(&p_sys->dts) - i_start;
 834         }
 835         p_sys->pts = VLC_TICK_INVALID;
 836     }
 837     hevc_release_sei_pic_timing(p_sys->p_timing);
 838     p_sys->p_timing = NULL;
 839 }
 840
 841 /*****************************************************************************
 842  * ParseNALBlock: parses annexB type NALs
 843  * All p_frag blocks are required to start with 0 0 0 1 4-byte startcode
 844  *****************************************************************************/
 845 static block_t *ParseNALBlock(decoder_t *p_dec, bool *pb_ts_used, block_t *p_frag)
 846 {
 847     decoder_sys_t *p_sys = p_dec->p_sys;
 848     *pb_ts_used = false;
 849
 850     if(p_sys->b_need_ts)
 851     {
 852         if(p_frag->i_dts != VLC_TICK_INVALID)
 853             date_Set(&p_sys->dts, p_frag->i_dts);
 854         p_sys->pts = p_frag->i_pts;
 855         if(date_Get( &p_sys->dts ) != VLC_TICK_INVALID)
 856             p_sys->b_need_ts = false;
 857         *pb_ts_used = true;
 858     }
 859
 860     if(unlikely(p_frag->i_buffer < 5))
 861     {
 862         msg_Warn(p_dec,"NAL too small");
 863         block_Release(p_frag);
 864         return NULL;
 865     }
 866
 867     if(p_frag->p_buffer[4] & 0x80)
 868     {
 869         msg_Warn(p_dec,"Forbidden zero bit not null, corrupted NAL");
 870         block_Release(p_frag);
 871         return GatherAndValidateChain(OutputQueues(p_sys, false)); /* will drop */
 872     }
 873
 874     /* Get NALU type */
 875     const vlc_tick_t dts = p_frag->i_dts, pts = p_frag->i_pts;
 876     block_t * p_output = NULL;
 877     uint8_t i_nal_type = hevc_getNALType(&p_frag->p_buffer[4]);
 878
 879     if (i_nal_type < HEVC_NAL_VPS)
 880     {
 881         /* NAL is a VCL NAL */
 882         p_output = ParseVCL(p_dec, i_nal_type, p_frag);
 883         if (p_output && (p_output->i_flags & BLOCK_FLAG_DROP))
 884             msg_Info(p_dec, "Waiting for VPS/SPS/PPS");
 885     }
 886     else
 887     {
 888         p_output = ParseNonVCL(p_dec, i_nal_type, p_frag);
 889     }
 890
 891     p_output = GatherAndValidateChain(p_output);
 892     if(p_output)
 893     {
 894         SetOutputBlockProperties( p_dec, p_output );
 895         if (dts != VLC_TICK_INVALID)
 896             date_Set(&p_sys->dts, dts);
 897         p_sys->pts = pts;
 898         *pb_ts_used = true;
 899     }
 900
 901     return p_output;
 902 }
 903
 904 static block_t *PacketizeParse(void *p_private, bool *pb_ts_used, block_t *p_block)
 905 {
 906     decoder_t *p_dec = p_private;
 907     decoder_sys_t *p_sys = p_dec->p_sys;
 908
 909     /* Remove trailing 0 bytes */
 910     while (p_block->i_buffer > 5 && p_block->p_buffer[p_block->i_buffer-1] == 0x00 )
 911         p_block->i_buffer--;
 912
 913     p_block = ParseNALBlock( p_dec, pb_ts_used, p_block );
 914     if( p_block )
 915         cc_storage_commit( p_sys->p_ccs, p_block );
 916
 917     return p_block;
 918 }
 919
 920 static int PacketizeValidate( void *p_private, block_t *p_au )
 921 {
 922     VLC_UNUSED(p_private);
 923     VLC_UNUSED(p_au);
 924     return VLC_SUCCESS;
 925 }
 926
 927 static bool ParseSEICallback( const hxxx_sei_data_t *p_sei_data, void *cbdata )
 928 {
 929     decoder_t *p_dec = (decoder_t *) cbdata;
 930     decoder_sys_t *p_sys = p_dec->p_sys;
 931
 932     switch( p_sei_data->i_type )
 933     {
 934         case HXXX_SEI_PIC_TIMING:
 935         {
 936             if( p_sys->p_active_sps )
 937             {
 938                 hevc_release_sei_pic_timing( p_sys->p_timing );
 939                 p_sys->p_timing = hevc_decode_sei_pic_timing( p_sei_data->p_bs,
 940                                                               p_sys->p_active_sps );
 941             }
 942         } break;
 943         case HXXX_SEI_USER_DATA_REGISTERED_ITU_T_T35:
 944         {
 945             if( p_sei_data->itu_t35.type == HXXX_ITU_T35_TYPE_CC )
 946             {
 947                 cc_storage_append( p_sys->p_ccs, true, p_sei_data->itu_t35.u.cc.p_data,
 948                                                        p_sei_data->itu_t35.u.cc.i_data );
 949             }
 950         } break;
 951         case HXXX_SEI_FRAME_PACKING_ARRANGEMENT:
 952         {
 953             if( p_dec->fmt_in.video.multiview_mode == MULTIVIEW_2D )
 954             {
 955                 video_multiview_mode_t mode;
 956                 switch( p_sei_data->frame_packing.type )
 957                 {
 958                     case FRAME_PACKING_INTERLEAVED_CHECKERBOARD:
 959                         mode = MULTIVIEW_STEREO_CHECKERBOARD; break;
 960                     case FRAME_PACKING_INTERLEAVED_COLUMN:
 961                         mode = MULTIVIEW_STEREO_COL; break;
 962                     case FRAME_PACKING_INTERLEAVED_ROW:
 963                         mode = MULTIVIEW_STEREO_ROW; break;
 964                     case FRAME_PACKING_SIDE_BY_SIDE:
 965                         mode = MULTIVIEW_STEREO_SBS; break;
 966                     case FRAME_PACKING_TOP_BOTTOM:
 967                         mode = MULTIVIEW_STEREO_TB; break;
 968                     case FRAME_PACKING_TEMPORAL:
 969                         mode = MULTIVIEW_STEREO_FRAME; break;
 970                     case FRAME_PACKING_TILED:
 971                     default:
 972                         mode = MULTIVIEW_2D; break;
 973                 }
 974                 p_dec->fmt_out.video.multiview_mode = mode;
 975             }
 976         } break;
 977         case HXXX_SEI_MASTERING_DISPLAY_COLOUR_VOLUME:
 978         {
 979             video_format_t *p_fmt = &p_dec->fmt_out.video;
 980             for (size_t i=0; i<ARRAY_SIZE(p_sei_data->colour_volume.primaries); ++i)
 981                 p_fmt->mastering.primaries[i] = p_sei_data->colour_volume.primaries[i];
 982             for (size_t i=0; i<ARRAY_SIZE(p_sei_data->colour_volume.white_point); ++i)
 983                 p_fmt->mastering.white_point[i] = p_sei_data->colour_volume.white_point[i];
 984             p_fmt->mastering.max_luminance = p_sei_data->colour_volume.max_luminance;
 985             p_fmt->mastering.min_luminance = p_sei_data->colour_volume.min_luminance;
 986         } break;
 987         case HXXX_SEI_CONTENT_LIGHT_LEVEL:
 988         {
 989             video_format_t *p_fmt = &p_dec->fmt_out.video;
 990             p_fmt->lighting.MaxCLL = p_sei_data->content_light_lvl.MaxCLL;
 991             p_fmt->lighting.MaxFALL = p_sei_data->content_light_lvl.MaxFALL;
 992         } break;
 993     }
 994
 995     return true;
 996 }