shenmc
/
bitstream
1
0
Fork 0
Code Issues 0 Pull Requests 0 Projects 0 Releases 0 Wiki Activity
Browse Source

h26x: add support for avcC and hvcC

master
Christophe Massiot 8 years ago
parent
981a3f4dd2
commit
29bbb853b9
2 changed files with 517 additions and 0 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +326
    -0
      itu/h265.h
  2. +191
    -0
      mpeg/h264.h

+ 326
- 0
itu/h265.h View File

@ -28,6 +28,7 @@
/*
* Normative references:
* - ITU-T H.265 (high efficiency video coding)
* - ISO/IEC 14496-15 2013 (AVC file format)
*/
#ifndef __BITSTREAM_ITU_H265_H__
@ -332,6 +333,331 @@ static inline void h265eob_init(uint8_t *p_h265eob)
#define H265SLI_TYPE_P 1
#define H265SLI_TYPE_I 2
/*****************************************************************************
* H265 hvcC structure
*****************************************************************************/
#define H265HVCC_HEADER 22
#define H265HVCC_ARRAY_HEADER 3
#define H265HVCC_NALU_HEADER 2
static inline void h265hvcc_init(uint8_t *p)
{
p[0] = 1; /* version */
p[1] = 0;
p[2] = 0;
p[3] = 0;
p[4] = 0;
p[5] = 0;
p[6] = 0;
p[7] = 0;
p[8] = 0;
p[9] = 0;
p[10] = 0;
p[11] = 0;
p[12] = 0;
p[13] = 0xf0;
p[14] = 0xfc;
p[15] = 0xfc;
p[16] = 0xf8;
p[17] = 0xf8;
p[18] = 0;
p[19] = 0;
p[20] = 0;
p[21] = 0;
}
static inline void h265hvcc_set_profile_space(uint8_t *p, uint8_t val)
{
p[1] &= ~0xc0;
p[1] |= val << 6;
}
static inline uint8_t h265hvcc_get_profile_space(const uint8_t *p)
{
return p[1] >> 6;
}
static inline void h265hvcc_set_tier(uint8_t *p)
{
p[1] |= 0x40;
}
static inline bool h265hvcc_get_tier(const uint8_t *p)
{
return p[1] & 0x40;
}
static inline void h265hvcc_set_profile_idc(uint8_t *p, uint8_t val)
{
p[1] &= ~0x1f;
p[1] |= val & 0x1f;
}
static inline uint8_t h265hvcc_get_profile_idc(const uint8_t *p)
{
return p[1] & 0x1f;
}
static inline void h265hvcc_set_profile_compatibility(uint8_t *p, uint32_t val)
{
p[2] = val >> 24;
p[3] = (val >> 16) & 0xff;
p[4] = (val >> 8) & 0xff;
p[5] = val & 0xff;
}
static inline uint32_t h265hvcc_get_profile_compatibility(const uint8_t *p)
{
return (p[2] << 24) | (p[3] << 16) | (p[4] << 8) | p[5];
}
static inline void h265hvcc_set_constraint_indicator(uint8_t *p, uint64_t val)
{
p[6] = val >> 40;
p[7] = (val >> 32) & 0xff;
p[8] = (val >> 24) & 0xff;
p[9] = (val >> 16) & 0xff;
p[10] = (val >> 8) & 0xff;
p[11] = val & 0xff;
}
static inline uint64_t h265hvcc_get_constraint_indicator(const uint8_t *p)
{
return ((uint64_t)p[6] << 40) |
((uint64_t)p[7] << 32) |
((uint64_t)p[8] << 24) |
((uint64_t)p[9] << 16) |
((uint64_t)p[10] << 8) |
(uint64_t)p[11];
}
static inline void h265hvcc_set_level_idc(uint8_t *p, uint8_t val)
{
p[12] = val;
}
static inline uint8_t h265hvcc_get_level_idc(const uint8_t *p)
{
return p[12];
}
static inline void h265hvcc_set_min_spatial_segmentation_idc(uint8_t *p, uint8_t val)
{
p[13] = 0xf0 | val;
}
static inline uint8_t h265hvcc_get_min_spatial_segmentation_idc(const uint8_t *p)
{
return p[13] & 0xf;
}
static inline void h265hvcc_set_parallelism_type(uint8_t *p, uint8_t val)
{
p[14] = 0xfc | val;
}
static inline uint8_t h265hvcc_get_parallelism_type(const uint8_t *p)
{
return p[14] & 0x3;
}
static inline void h265hvcc_set_chroma_format(uint8_t *p, uint8_t val)
{
p[15] = 0xfc | val;
}
static inline uint8_t h265hvcc_get_chroma_format(const uint8_t *p)
{
return p[15] & 0x3;
}
static inline void h265hvcc_set_bitdepth_luma_8(uint8_t *p, uint8_t val)
{
p[16] = 0xf8 | val;
}
static inline uint8_t h265hvcc_get_bitdepth_luma_8(const uint8_t *p)
{
return p[16] & 0x7;
}
static inline void h265hvcc_set_bitdepth_chroma_8(uint8_t *p, uint8_t val)
{
p[17] = 0xf8 | val;
}
static inline uint8_t h265hvcc_get_bitdepth_chroma_8(const uint8_t *p)
{
return p[17] & 0x7;
}
static inline void h265hvcc_set_avg_frame_rate(uint8_t *p, uint16_t val)
{
p[18] = val >> 8;
p[19] = val & 0xff;
}
static inline uint32_t h265hvcc_get_avg_frame_rate(const uint8_t *p)
{
return (p[18] << 8) | p[19];
}
static inline void h265hvcc_set_constant_frame_rate(uint8_t *p, uint8_t val)
{
p[20] &= ~0xc0;
p[20] |= val << 6;
}
static inline uint8_t h265hvcc_get_constant_frame_rate(const uint8_t *p)
{
return p[20] >> 6;
}
static inline void h265hvcc_set_num_temporal_layers(uint8_t *p, uint8_t val)
{
p[21] &= ~0x38;
p[21] |= val << 3;
}
static inline uint8_t h265hvcc_get_num_temporal_layers(const uint8_t *p)
{
return (p[21] >> 3) & 0x3;
}
static inline void h265hvcc_set_temporal_id_nested(uint8_t *p)
{
p[21] |= 0x4;
}
static inline bool h265hvcc_get_temporal_id_nested(const uint8_t *p)
{
return p[21] & 0x4;
}
static inline void h265hvcc_set_length_size_1(uint8_t *p, uint8_t val)
{
p[21] &= ~0x3;
p[21] |= val;
}
static inline uint8_t h265hvcc_get_length_size_1(const uint8_t *p)
{
return p[21] & 0x3;
}
static inline void h265hvcc_set_num_of_arrays(uint8_t *p, uint8_t val)
{
p[22] = val;
}
static inline uint8_t h265hvcc_get_num_of_arrays(const uint8_t *p)
{
return p[22];
}
static inline void h265hvcc_nalu_set_length(uint8_t *p, uint16_t val)
{
p[0] = val >> 8;
p[1] = val & 0xff;
}
static inline uint16_t h265hvcc_nalu_get_length(const uint8_t *p)
{
return (p[0] << 8) | p[1];
}
static inline uint8_t *h265hvcc_nalu_get_nalu(const uint8_t *p)
{
return (uint8_t *)p + H265HVCC_NALU_HEADER;
}
static inline void h265hvcc_array_init(uint8_t *p)
{
p[0] = 0;
}
static inline void h265hvcc_array_set_completeness(uint8_t *p)
{
p[0] |= 0x80;
}
static inline bool h265hvcc_array_get_completeness(const uint8_t *p)
{
return p[0] & 0x80;
}
static inline void h265hvcc_array_set_nal_unit_type(uint8_t *p, uint8_t val)
{
p[0] &= ~0x3f;
p[0] |= val;
}
static inline uint8_t h265hvcc_array_get_nal_unit_type(const uint8_t *p)
{
return p[0] & 0x3f;
}
static inline void h265hvcc_array_set_num_nalus(uint8_t *p, uint16_t val)
{
p[1] = val >> 8;
p[2] = val & 0xff;
}
static inline uint16_t h265hvcc_array_get_num_nalus(const uint8_t *p)
{
return (p[1] << 8) | p[2];
}
static inline uint8_t *h265hvcc_array_get_nalu(const uint8_t *p, uint8_t n)
{
p += H265HVCC_ARRAY_HEADER;
while (n) {
uint16_t length = h265hvcc_nalu_get_length(p);
p += H265HVCC_NALU_HEADER + length;
n--;
}
return (uint8_t *)p;
}
static inline uint8_t *h265hvcc_get_array(const uint8_t *p, uint8_t n)
{
p += H265HVCC_HEADER;
while (n) {
uint16_t num_nalus = h265hvcc_array_get_num_nalus(p);
p = h265hvcc_array_get_nalu(p, num_nalus);
n--;
}
return (uint8_t *)p;
}
static inline bool h265hvcc_validate(const uint8_t *p, size_t size)
{
/* apparenty there is a prerelease with version = 0 */
if (p[0] != 1 && p[0] != 0)
return false;
if (size < H265HVCC_HEADER)
return false;
uint8_t num_arrays = h265hvcc_get_num_of_arrays(p);
uint8_t array = 0;
while (array < num_arrays) {
const uint8_t *a = h265hvcc_get_array(p, array++);
if (a + H265HVCC_ARRAY_HEADER > p + size)
return false;
uint8_t num_nalus = h265hvcc_array_get_num_nalus(a);
uint8_t nalu = 0;
while (nalu < num_nalus)
if (h265hvcc_array_get_nalu(a, nalu++) + H265HVCC_NALU_HEADER > p + size)
return false;
}
if (h265hvcc_get_array(p, num_arrays) > p + size)
return false;
return true;
}
#ifdef __cplusplus
}
#endif

+ 191
- 0
mpeg/h264.h View File

@ -28,6 +28,7 @@
/*
* Normative references:
* - ISO/IEC 14496-10 (advanced video coding)
* - ISO/IEC 14496-15 (advanced video coding file format)
*/
#ifndef __BITSTREAM_MPEG_H264_H__
@ -101,6 +102,35 @@ static inline uint8_t h264nalst_get_type(uint8_t start)
return start & 0x1f;
}
static inline bool h264naltype_is_slice(uint8_t type)
{
switch (type) {
case H264NAL_TYPE_IDR:
case H264NAL_TYPE_NONIDR:
case H264NAL_TYPE_PARTA:
case H264NAL_TYPE_PARTB:
case H264NAL_TYPE_PARTC:
return true;
default:
return false;
}
}
static inline bool h264naltype_is_vcl(uint8_t type)
{
switch (type) {
case H264NAL_TYPE_IDR:
case H264NAL_TYPE_NONIDR:
case H264NAL_TYPE_PARTA:
case H264NAL_TYPE_PARTB:
case H264NAL_TYPE_PARTC:
case H264NAL_TYPE_SEI:
return true;
default:
return false;
}
}
/*****************************************************************************
* H264 supplemental enhancement information
*****************************************************************************/
@ -305,6 +335,167 @@ static inline void h264ssps_init(uint8_t *p_h264ssps)
#define H264SLI_TYPE_SP 3
#define H264SLI_TYPE_SI 4
/*****************************************************************************
* H264 avcC structure
*****************************************************************************/
#define H264AVCC_HEADER 6
#define H264AVCC_HEADER2 1
#define H264AVCC_SPS_HEADER 2
#define H264AVCC_PPS_HEADER 2
static inline void h264avcc_init(uint8_t *p)
{
p[0] = 1; /* version */
p[4] = 0xfc;
p[5] = 0xe0;
}
static inline void h264avcc_set_profile(uint8_t *p, uint8_t val)
{
p[1] = val;
}
static inline uint8_t h264avcc_get_profile(const uint8_t *p)
{
return p[1];
}
static inline void h264avcc_set_profile_compatibility(uint8_t *p, uint8_t val)
{
p[2] = val;
}
static inline uint8_t h264avcc_get_profile_compatibility(const uint8_t *p)
{
return p[2];
}
static inline void h264avcc_set_level(uint8_t *p, uint8_t val)
{
p[3] = val;
}
static inline uint8_t h264avcc_get_level(const uint8_t *p)
{
return p[3];
}
static inline void h264avcc_set_length_size_1(uint8_t *p, uint8_t val)
{
p[4] = 0xfc | val;
}
static inline uint8_t h264avcc_get_length_size_1(const uint8_t *p)
{
return p[4] & 0x3;
}
static inline void h264avcc_set_nb_sps(uint8_t *p, uint8_t val)
{
p[5] = 0xe0 | val;
}
static inline uint8_t h264avcc_get_nb_sps(const uint8_t *p)
{
return p[5] & 0x1f;
}
static inline void h264avcc_spsh_set_length(uint8_t *p, uint16_t val)
{
p[0] = val >> 8;
p[1] = val & 0xff;
}
static inline uint16_t h264avcc_spsh_get_length(const uint8_t *p)
{
return (p[0] << 8) | p[1];
}
static inline uint8_t *h264avcc_spsh_get_sps(const uint8_t *p)
{
return (uint8_t *)p + H264AVCC_SPS_HEADER;
}
static inline uint8_t *h264avcc_get_spsh(const uint8_t *p, uint8_t n)
{
p += H264AVCC_HEADER;
while (n) {
uint16_t length = h264avcc_spsh_get_length(p);
p += H264AVCC_SPS_HEADER + length;
n--;
}
return (uint8_t *)p;
}
static inline void h264avcc_set_nb_pps(uint8_t *p, uint8_t val)
{
p = h264avcc_get_spsh(p, h264avcc_get_nb_sps(p));
p[0] = val;
}
static inline uint8_t h264avcc_get_nb_pps(const uint8_t *p)
{
p = h264avcc_get_spsh(p, h264avcc_get_nb_sps(p));
return p[0];
}
static inline void h264avcc_ppsh_set_length(uint8_t *p, uint16_t val)
{
p[0] = val >> 8;
p[1] = val & 0xff;
}
static inline uint16_t h264avcc_ppsh_get_length(const uint8_t *p)
{
return (p[0] << 8) | p[1];
}
static inline uint8_t *h264avcc_ppsh_get_pps(const uint8_t *p)
{
return (uint8_t *)p + H264AVCC_PPS_HEADER;
}
static inline uint8_t *h264avcc_get_ppsh(const uint8_t *p, uint8_t n)
{
p = h264avcc_get_spsh(p, h264avcc_get_nb_sps(p));
p += H264AVCC_HEADER2;
while (n) {
uint16_t length = h264avcc_ppsh_get_length(p);
p += H264AVCC_PPS_HEADER + length;
n--;
}
return (uint8_t *)p;
}
static inline bool h264avcc_validate(const uint8_t *p, size_t size)
{
if (p[0] != 1)
return false;
/* don't check reserved bits as it is a common mistake */
if (size < H264AVCC_HEADER + H264AVCC_HEADER2)
return false;
uint8_t nb = h264avcc_get_nb_sps(p);
uint8_t n = 0;
while (n < nb)
if (h264avcc_get_spsh(p, n++) + H264AVCC_SPS_HEADER > p + size)
return false;
if (h264avcc_get_spsh(p, n) + H264AVCC_HEADER2 > p + size)
return false;
nb = h264avcc_get_nb_pps(p);
n = 0;
while (n < nb)
if (h264avcc_get_ppsh(p, n++) + H264AVCC_PPS_HEADER > p + size)
return false;
if (h264avcc_get_ppsh(p, n) > p + size)
return false;
return true;
}
#ifdef __cplusplus
}
#endif

Write Preview
Loading…
Cancel
Save