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. More...

#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. More...

#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. More...

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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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.

◆ 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.

◆ 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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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.

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