H.264 Format Attribute Module. More...

#include "asterisk.h"
#include "asterisk/module.h"
#include "asterisk/format.h"

Include dependency graph for res_format_attr_h264.c:

Data Structures
struct	h264_attr

Macros
#define	APPEND_IF_NONZERO(field, str, name)

#define	APPEND_IF_NOT_H264_UNSET(field, str, name)

#define	DETERMINE_JOINT(joint, attr1, attr2, field) (joint->field = (attr1 && attr1->field) ? attr1->field : (attr2 && attr2->field) ? attr2->field : 0)

#define	H264_ATTR_KEY_UNSET UINT8_MAX
	Value that indicates an attribute is actually unset.

#define	H264_MAX_SPS_PPS_SIZE 16
	Maximum size for SPS / PPS values in sprop-parameter-sets attribute if you change this value then you must change H264_MAX_SPS_PPS_SIZE_SCAN_LIMIT as well.

#define	H264_MAX_SPS_PPS_SIZE_SCAN_LIMIT "15"
	This is used when executing sscanf on buffers of H264_MAX_SPS_PPS_SIZE length. It must ALWAYS be a string literal representation of one less than H264_MAX_SPS_PPS_SIZE.

Functions
static void	__reg_module (void)

static void	__unreg_module (void)

struct ast_module *	AST_MODULE_SELF_SYM (void)

static int	h264_clone (const struct ast_format src, struct ast_format dst)

static enum ast_format_cmp_res	h264_cmp (const struct ast_format format1, const struct ast_format format2)

static void	h264_destroy (struct ast_format *format)

static void	h264_generate_sdp_fmtp (const struct ast_format format, unsigned int payload, struct ast_str *str)

static struct ast_format *	h264_getjoint (const struct ast_format format1, const struct ast_format format2)

static struct ast_format *	h264_parse_sdp_fmtp (const struct ast_format format, const char attributes)

static int	load_module (void)

static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "H.264 Format Attribute Module" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, }

static const struct ast_module_info *	ast_module_info = &__mod_info

static struct ast_format_interface	h264_interface

Detailed Description

H.264 Format Attribute Module.

Author

Joshua Colp <jcolp@digium.com>

This is a format attribute module for the H.264 codec.

Definition in file res_format_attr_h264.c.

Macro Definition Documentation

◆ APPEND_IF_NONZERO

#define APPEND_IF_NONZERO	(	field,
		str,
		name
	)

Definition at line 246 of file res_format_attr_h264.c.

                                               {        \
    if (field) {    \
        if (added) {    \
            ast_str_append(str, 0, ";");    \
        } else if (0 < ast_str_append(str, 0, "a=fmtp:%u ", payload)) { \
            added = 1;  \
        }   \
        ast_str_append(str, 0, "%s=%u", name, field);   \
    }   \
} while (0)

◆ APPEND_IF_NOT_H264_UNSET

#define APPEND_IF_NOT_H264_UNSET	(	field,
		str,
		name
	)

Definition at line 235 of file res_format_attr_h264.c.

                                                      {     \
    if (field != H264_ATTR_KEY_UNSET) { \
        if (added) {    \
            ast_str_append(str, 0, ";");    \
        } else if (0 < ast_str_append(str, 0, "a=fmtp:%u ", payload)) { \
            added = 1;  \
        }   \
        ast_str_append(str, 0, "%s=%u", name, field);   \
    }   \
} while (0)

◆ DETERMINE_JOINT

#define DETERMINE_JOINT	(	joint,
		attr1,
		attr2,
		field
	)	(joint->field = (attr1 && attr1->field) ? attr1->field : (attr2 && attr2->field) ? attr2->field : 0)

Definition at line 114 of file res_format_attr_h264.c.

◆ H264_ATTR_KEY_UNSET

#define H264_ATTR_KEY_UNSET UINT8_MAX

Value that indicates an attribute is actually unset.

Definition at line 40 of file res_format_attr_h264.c.

◆ H264_MAX_SPS_PPS_SIZE

#define H264_MAX_SPS_PPS_SIZE 16

Maximum size for SPS / PPS values in sprop-parameter-sets attribute if you change this value then you must change H264_MAX_SPS_PPS_SIZE_SCAN_LIMIT as well.

Definition at line 45 of file res_format_attr_h264.c.

◆ H264_MAX_SPS_PPS_SIZE_SCAN_LIMIT

#define H264_MAX_SPS_PPS_SIZE_SCAN_LIMIT "15"

This is used when executing sscanf on buffers of H264_MAX_SPS_PPS_SIZE length. It must ALWAYS be a string literal representation of one less than H264_MAX_SPS_PPS_SIZE.

Definition at line 49 of file res_format_attr_h264.c.

Function Documentation

◆ __reg_module()

static void __reg_module ( void )

static

Definition at line 337 of file res_format_attr_h264.c.

◆ __unreg_module()

static void __unreg_module ( void )

static

Definition at line 337 of file res_format_attr_h264.c.

◆ AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM ( void )

Definition at line 337 of file res_format_attr_h264.c.

◆ h264_clone()

static int h264_clone	(	const struct ast_format *	src,
		struct ast_format *	dst
	)

static

Definition at line 83 of file res_format_attr_h264.c.

{
    struct h264_attr *original = ast_format_get_attribute_data(src);
    struct h264_attr *attr = ast_calloc(1, sizeof(*attr));
 
    if (!attr) {
        return -1;
    }
 
    if (original) {
        *attr = *original;
    }
 
    ast_format_set_attribute_data(dst, attr);
 
    return 0;
}

References ast_calloc, ast_format_get_attribute_data(), and ast_format_set_attribute_data().

◆ h264_cmp()

static enum ast_format_cmp_res h264_cmp	(	const struct ast_format *	format1,
		const struct ast_format *	format2
	)

static

Definition at line 101 of file res_format_attr_h264.c.

{
    struct h264_attr *attr1 = ast_format_get_attribute_data(format1);
    struct h264_attr *attr2 = ast_format_get_attribute_data(format2);
 
    if (!attr1 || !attr1->PROFILE_IDC || !attr2 || !attr2->PROFILE_IDC ||
        (attr1->PROFILE_IDC == attr2->PROFILE_IDC)) {
        return AST_FORMAT_CMP_EQUAL;
    }
 
    return AST_FORMAT_CMP_NOT_EQUAL;
}

References AST_FORMAT_CMP_EQUAL, AST_FORMAT_CMP_NOT_EQUAL, ast_format_get_attribute_data(), and h264_attr::PROFILE_IDC.

◆ h264_destroy()

static void h264_destroy ( struct ast_format * format )

static

Definition at line 76 of file res_format_attr_h264.c.

{
    struct h264_attr *attr = ast_format_get_attribute_data(format);
 
    ast_free(attr);
}

References ast_format_get_attribute_data(), and ast_free.

◆ h264_generate_sdp_fmtp()

static void h264_generate_sdp_fmtp	(	const struct ast_format *	format,
		unsigned int	payload,
		struct ast_str **	str
	)

static

Definition at line 257 of file res_format_attr_h264.c.

{
    struct h264_attr *attr = ast_format_get_attribute_data(format);
    int added = 0;
 
    if (!attr) {
        return;
    }
 
    APPEND_IF_NONZERO(attr->MAX_MBPS, str, "max-mbps");
    APPEND_IF_NONZERO(attr->MAX_FS, str, "max-fs");
    APPEND_IF_NONZERO(attr->MAX_CPB, str, "max-cpb");
    APPEND_IF_NONZERO(attr->MAX_DPB, str, "max-dpb");
    APPEND_IF_NONZERO(attr->MAX_BR, str, "max-br");
    APPEND_IF_NONZERO(attr->MAX_SMBPS, str, "max-smbps");
    APPEND_IF_NONZERO(attr->MAX_FPS, str, "max-fps");
    APPEND_IF_NONZERO(attr->SPROP_INTERLEAVING_DEPTH, str, "sprop-interleaving-depth");
    APPEND_IF_NONZERO(attr->SPROP_DEINT_BUF_REQ, str, "sprop-deint-buf-req");
    APPEND_IF_NONZERO(attr->DEINT_BUF_CAP, str, "deint-buf-cap");
    APPEND_IF_NONZERO(attr->SPROP_INIT_BUF_TIME, str, "sprop-init-buf-time");
    APPEND_IF_NONZERO(attr->SPROP_MAX_DON_DIFF, str, "sprop-max-don-diff");
    APPEND_IF_NONZERO(attr->MAX_RCMD_NALU_SIZE, str, "max-rcmd-nalu-size");
 
    APPEND_IF_NOT_H264_UNSET(attr->REDUNDANT_PIC_CAP, str, "redundant-pic-cap");
    APPEND_IF_NOT_H264_UNSET(attr->PARAMETER_ADD, str, "parameter-add");
    APPEND_IF_NOT_H264_UNSET(attr->PACKETIZATION_MODE, str, "packetization-mode");
    APPEND_IF_NOT_H264_UNSET(attr->LEVEL_ASYMMETRY_ALLOWED, str, "level-asymmetry-allowed");
 
    if (attr->PROFILE_IDC && attr->LEVEL) {
        if (added) {
            ast_str_append(str, 0, ";");
        } else if (0 < ast_str_append(str, 0, "a=fmtp:%u ", payload)) {
            added = 1;
        }
        ast_str_append(str, 0, "profile-level-id=%02X%02X%02X", attr->PROFILE_IDC, attr->PROFILE_IOP, attr->LEVEL);
    }
 
    if (!ast_strlen_zero(attr->SPS) && !ast_strlen_zero(attr->PPS)) {
        if (added) {
            ast_str_append(str, 0, ";");
        } else if (0 < ast_str_append(str, 0, "a=fmtp:%u ", payload)) {
            added = 1;
        }
        ast_str_append(str, 0, "sprop-parameter-sets=%s,%s", attr->SPS, attr->PPS);
    }
 
    if (added) {
        ast_str_append(str, 0, "\r\n");
    }
 
    return;
}

References APPEND_IF_NONZERO, APPEND_IF_NOT_H264_UNSET, ast_format_get_attribute_data(), ast_str_append(), ast_strlen_zero(), h264_attr::DEINT_BUF_CAP, h264_attr::LEVEL, h264_attr::LEVEL_ASYMMETRY_ALLOWED, h264_attr::MAX_BR, h264_attr::MAX_CPB, h264_attr::MAX_DPB, h264_attr::MAX_FPS, h264_attr::MAX_FS, h264_attr::MAX_MBPS, h264_attr::MAX_RCMD_NALU_SIZE, h264_attr::MAX_SMBPS, h264_attr::PACKETIZATION_MODE, h264_attr::PARAMETER_ADD, h264_attr::PPS, h264_attr::PROFILE_IDC, h264_attr::PROFILE_IOP, h264_attr::REDUNDANT_PIC_CAP, h264_attr::SPROP_DEINT_BUF_REQ, h264_attr::SPROP_INIT_BUF_TIME, h264_attr::SPROP_INTERLEAVING_DEPTH, h264_attr::SPROP_MAX_DON_DIFF, h264_attr::SPS, and str.

◆ h264_getjoint()

static struct ast_format * h264_getjoint	(	const struct ast_format *	format1,
		const struct ast_format *	format2
	)

static

Definition at line 116 of file res_format_attr_h264.c.

{
    struct ast_format *cloned;
    struct h264_attr *attr, *attr1, *attr2;
 
    cloned = ast_format_clone(format1);
    if (!cloned) {
        return NULL;
    }
    attr = ast_format_get_attribute_data(cloned);
 
    attr1 = ast_format_get_attribute_data(format1);
    attr2 = ast_format_get_attribute_data(format2);
 
    DETERMINE_JOINT(attr, attr1, attr2, PROFILE_IDC);
    DETERMINE_JOINT(attr, attr1, attr2, PROFILE_IOP);
    DETERMINE_JOINT(attr, attr1, attr2, LEVEL);
    DETERMINE_JOINT(attr, attr1, attr2, MAX_MBPS);
    DETERMINE_JOINT(attr, attr1, attr2, MAX_FS);
    DETERMINE_JOINT(attr, attr1, attr2, MAX_CPB);
    DETERMINE_JOINT(attr, attr1, attr2, MAX_DPB);
    DETERMINE_JOINT(attr, attr1, attr2, MAX_BR);
    DETERMINE_JOINT(attr, attr1, attr2, MAX_SMBPS);
    DETERMINE_JOINT(attr, attr1, attr2, MAX_FPS);
    DETERMINE_JOINT(attr, attr1, attr2, REDUNDANT_PIC_CAP);
    DETERMINE_JOINT(attr, attr1, attr2, PARAMETER_ADD);
    DETERMINE_JOINT(attr, attr1, attr2, SPROP_INTERLEAVING_DEPTH);
    DETERMINE_JOINT(attr, attr1, attr2, SPROP_DEINT_BUF_REQ);
    DETERMINE_JOINT(attr, attr1, attr2, DEINT_BUF_CAP);
    DETERMINE_JOINT(attr, attr1, attr2, SPROP_INIT_BUF_TIME);
    DETERMINE_JOINT(attr, attr1, attr2, SPROP_MAX_DON_DIFF);
    DETERMINE_JOINT(attr, attr1, attr2, MAX_RCMD_NALU_SIZE);
    DETERMINE_JOINT(attr, attr1, attr2, LEVEL_ASYMMETRY_ALLOWED);
    DETERMINE_JOINT(attr, attr1, attr2, PACKETIZATION_MODE);
 
    if (attr1 && !ast_strlen_zero(attr1->SPS)) {
        ast_copy_string(attr->SPS, attr1->SPS, sizeof(attr->SPS));
    } else if (attr2 && !ast_strlen_zero(attr2->SPS)) {
        ast_copy_string(attr->SPS, attr2->SPS, sizeof(attr->SPS));
    }
 
    if (attr1 && !ast_strlen_zero(attr1->PPS)) {
        ast_copy_string(attr->PPS, attr1->PPS, sizeof(attr->PPS));
    } else if (attr2 && !ast_strlen_zero(attr2->PPS)) {
        ast_copy_string(attr->PPS, attr2->PPS, sizeof(attr->PPS));
    }
 
    return cloned;
}

References ast_copy_string(), ast_format_clone(), ast_format_get_attribute_data(), ast_strlen_zero(), h264_attr::DEINT_BUF_CAP, DETERMINE_JOINT, h264_attr::LEVEL, h264_attr::LEVEL_ASYMMETRY_ALLOWED, h264_attr::MAX_BR, h264_attr::MAX_CPB, h264_attr::MAX_DPB, h264_attr::MAX_FPS, h264_attr::MAX_FS, h264_attr::MAX_MBPS, h264_attr::MAX_RCMD_NALU_SIZE, h264_attr::MAX_SMBPS, NULL, h264_attr::PACKETIZATION_MODE, h264_attr::PARAMETER_ADD, h264_attr::PPS, h264_attr::PROFILE_IDC, h264_attr::PROFILE_IOP, h264_attr::REDUNDANT_PIC_CAP, h264_attr::SPROP_DEINT_BUF_REQ, h264_attr::SPROP_INIT_BUF_TIME, h264_attr::SPROP_INTERLEAVING_DEPTH, h264_attr::SPROP_MAX_DON_DIFF, and h264_attr::SPS.

◆ h264_parse_sdp_fmtp()

static struct ast_format * h264_parse_sdp_fmtp	(	const struct ast_format *	format,
		const char *	attributes
	)

static

Definition at line 166 of file res_format_attr_h264.c.

{
    char *attribs = ast_strdupa(attributes), *attrib;
    struct ast_format *cloned;
    struct h264_attr *attr;
 
    cloned = ast_format_clone(format);
    if (!cloned) {
        return NULL;
    }
    attr = ast_format_get_attribute_data(cloned);
 
    attr->REDUNDANT_PIC_CAP = H264_ATTR_KEY_UNSET;
    attr->PARAMETER_ADD = H264_ATTR_KEY_UNSET;
    attr->PACKETIZATION_MODE = H264_ATTR_KEY_UNSET;
    attr->LEVEL_ASYMMETRY_ALLOWED = H264_ATTR_KEY_UNSET;
 
    while ((attrib = strsep(&attribs, ";"))) {
        unsigned int val;
        unsigned long int val2;
 
        attrib = ast_strip(attrib);
 
        if (sscanf(attrib, "profile-level-id=%lx", &val2) == 1) {
            attr->PROFILE_IDC = ((val2 >> 16) & 0xFF);
            attr->PROFILE_IOP = ((val2 >> 8) & 0xFF);
            attr->LEVEL = (val2 & 0xFF);
        } else if (sscanf(attrib, "sprop-parameter-sets=%" H264_MAX_SPS_PPS_SIZE_SCAN_LIMIT "[^','],%" H264_MAX_SPS_PPS_SIZE_SCAN_LIMIT "s", attr->SPS, attr->PPS) == 2) {
            /* XXX sprop-parameter-sets can actually be of unlimited length. This may need to be addressed later. */
        } else if (sscanf(attrib, "max-mbps=%30u", &val) == 1) {
            attr->MAX_MBPS = val;
        } else if (sscanf(attrib, "max-fs=%30u", &val) == 1) {
            attr->MAX_FS = val;
        } else if (sscanf(attrib, "max-cpb=%30u", &val) == 1) {
            attr->MAX_CPB = val;
        } else if (sscanf(attrib, "max-dpb=%30u", &val) == 1) {
            attr->MAX_DPB = val;
        } else if (sscanf(attrib, "max-br=%30u", &val) == 1) {
            attr->MAX_BR = val;
        } else if (sscanf(attrib, "max-smbps=%30u", &val) == 1) {
            attr->MAX_SMBPS = val;
        } else if (sscanf(attrib, "max-fps=%30u", &val) == 1) {
            attr->MAX_FPS = val;
        } else if (sscanf(attrib, "redundant-pic-cap=%30u", &val) == 1) {
            attr->REDUNDANT_PIC_CAP = val;
        } else if (sscanf(attrib, "parameter-add=%30u", &val) == 1) {
            attr->PARAMETER_ADD = val;
        } else if (sscanf(attrib, "packetization-mode=%30u", &val) == 1) {
            attr->PACKETIZATION_MODE = val;
        } else if (sscanf(attrib, "sprop-interleaving-depth=%30u", &val) == 1) {
            attr->SPROP_INTERLEAVING_DEPTH = val;
        } else if (sscanf(attrib, "sprop-deint-buf-req=%30u", &val) == 1) {
            attr->SPROP_DEINT_BUF_REQ = val;
        } else if (sscanf(attrib, "deint-buf-cap=%30u", &val) == 1) {
            attr->DEINT_BUF_CAP = val;
        } else if (sscanf(attrib, "sprop-init-buf-time=%30u", &val) == 1) {
            attr->SPROP_INIT_BUF_TIME = val;
        } else if (sscanf(attrib, "sprop-max-don-diff=%30u", &val) == 1) {
            attr->SPROP_MAX_DON_DIFF = val;
        } else if (sscanf(attrib, "max-rcmd-nalu-size=%30u", &val) == 1) {
            attr->MAX_RCMD_NALU_SIZE = val;
        } else if (sscanf(attrib, "level-asymmetry-allowed=%30u", &val) == 1) {
            attr->LEVEL_ASYMMETRY_ALLOWED = val;
        }
    }
 
    return cloned;
}

References ast_format_clone(), ast_format_get_attribute_data(), ast_strdupa, ast_strip(), h264_attr::DEINT_BUF_CAP, H264_ATTR_KEY_UNSET, H264_MAX_SPS_PPS_SIZE_SCAN_LIMIT, h264_attr::LEVEL, h264_attr::LEVEL_ASYMMETRY_ALLOWED, h264_attr::MAX_BR, h264_attr::MAX_CPB, h264_attr::MAX_DPB, h264_attr::MAX_FPS, h264_attr::MAX_FS, h264_attr::MAX_MBPS, h264_attr::MAX_RCMD_NALU_SIZE, h264_attr::MAX_SMBPS, NULL, h264_attr::PACKETIZATION_MODE, h264_attr::PARAMETER_ADD, h264_attr::PPS, h264_attr::PROFILE_IDC, h264_attr::PROFILE_IOP, h264_attr::REDUNDANT_PIC_CAP, h264_attr::SPROP_DEINT_BUF_REQ, h264_attr::SPROP_INIT_BUF_TIME, h264_attr::SPROP_INTERLEAVING_DEPTH, h264_attr::SPROP_MAX_DON_DIFF, h264_attr::SPS, and strsep().

◆ load_module()

static int load_module ( void )

static

Definition at line 324 of file res_format_attr_h264.c.

{
    if (ast_format_interface_register("h264", &h264_interface)) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    return AST_MODULE_LOAD_SUCCESS;
}

References ast_format_interface_register, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, and h264_interface.

◆ unload_module()

static int unload_module ( void )

static

Definition at line 319 of file res_format_attr_h264.c.

{
    return 0;
}

Variable Documentation

◆ __mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "H.264 Format Attribute Module" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, }

static

Definition at line 337 of file res_format_attr_h264.c.

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 337 of file res_format_attr_h264.c.

◆ h264_interface

struct ast_format_interface h264_interface

static

Definition at line 310 of file res_format_attr_h264.c.

                                                    {
    .format_destroy = h264_destroy,
    .format_clone = h264_clone,
    .format_cmp = h264_cmp,
    .format_get_joint = h264_getjoint,
    .format_parse_sdp_fmtp = h264_parse_sdp_fmtp,
    .format_generate_sdp_fmtp = h264_generate_sdp_fmtp,
};

Referenced by load_module().

Data Structures

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ APPEND_IF_NONZERO

◆ APPEND_IF_NOT_H264_UNSET

◆ DETERMINE_JOINT

◆ H264_ATTR_KEY_UNSET

◆ H264_MAX_SPS_PPS_SIZE

◆ H264_MAX_SPS_PPS_SIZE_SCAN_LIMIT

Function Documentation

◆ __reg_module()

◆ __unreg_module()

◆ AST_MODULE_SELF_SYM()

◆ h264_clone()

◆ h264_cmp()

◆ h264_destroy()

◆ h264_generate_sdp_fmtp()

◆ h264_getjoint()

◆ h264_parse_sdp_fmtp()

◆ load_module()

◆ unload_module()

Variable Documentation

◆ __mod_info

◆ ast_module_info

◆ h264_interface