Obtenir la largeur / hauteur de la vidéo de H. 264 NALU
J'ai obtenu l'accord SPS dans NALU ( AVC Decoder Configuration de l'Enregistrement ), et en essayant d'analyser la vidéo de la largeur /hauteur de.
67 64 00 15 ac c8 60 20 09 6c 04 40 00 00 03 00 40 00 00 07 a3 c5 8b 67 80
C'est mon code d'analyser le SPS, mais se fait de fausses valeurs.
pic_width_in_mbs_minus1 est de 5, et pic_height_in_map_units_minus1 est 1.
En fait la vidéo est de 512 X 288px
typedef struct _SequenceParameterSet
{
private:
const unsigned char * m_pStart;
unsigned short m_nLength;
int m_nCurrentBit;
unsigned int ReadBit()
{
ATLASSERT(m_nCurrentBit <= m_nLength * 8);
int nIndex = m_nCurrentBit /8;
int nOffset = m_nCurrentBit % 8 + 1;
m_nCurrentBit ++;
return (m_pStart[nIndex] >> (8-nOffset)) & 0x01;
}
unsigned int ReadBits(int n)
{
int r = 0;
int i;
for (i = 0; i < n; i++)
{
r |= ( ReadBit() << ( n - i - 1 ) );
}
return r;
}
unsigned int ReadExponentialGolombCode()
{
int r = 0;
int i = 0;
while( (ReadBit() == 0) && (i < 32) )
{
i++;
}
r = ReadBits(i);
r += (1 << i) - 1;
return r;
}
unsigned int ReadSE()
{
int r = ReadExponentialGolombCode();
if (r & 0x01)
{
r = (r+1)/2;
}
else
{
r = -(r/2);
}
return r;
}
public:
void Parse(const unsigned char * pStart, unsigned short nLen)
{
m_pStart = pStart;
m_nLength = nLen;
m_nCurrentBit = 0;
int profile_idc = ReadBits(8);
int constraint_set0_flag = ReadBit();
int constraint_set1_flag = ReadBit();
int constraint_set2_flag = ReadBit();
int constraint_set3_flag = ReadBit();
int constraint_set4_flag = ReadBit();
int constraint_set5_flag = ReadBit();
int reserved_zero_2bits = ReadBits(2);
int level_idc = ReadBits(8);
int seq_parameter_set_id = ReadExponentialGolombCode();
if( profile_idc == 100 || profile_idc == 110 ||
profile_idc == 122 || profile_idc == 144 )
{
int chroma_format_idc = ReadExponentialGolombCode();
if( chroma_format_idc == 3 )
{
int residual_colour_transform_flag = ReadBit();
}
int bit_depth_luma_minus8 = ReadExponentialGolombCode();
int bit_depth_chroma_minus8 = ReadExponentialGolombCode();
int qpprime_y_zero_transform_bypass_flag = ReadBit();
int seq_scaling_matrix_present_flag = ReadBit();
if( seq_scaling_matrix_present_flag )
{
for( int i = 0; i < 8; i++ )
{
int seq_scaling_list_present_flag = ReadBit();
if( seq_scaling_list_present_flag )
{
/*
if( i < 6 )
{
read_scaling_list( b, sps->ScalingList4x4[ i ], 16,
sps->UseDefaultScalingMatrix4x4Flag[ i ]);
}
else
{
read_scaling_list( b, sps->ScalingList8x8[ i - 6 ], 64,
sps->UseDefaultScalingMatrix8x8Flag[ i - 6 ] );
}
*/
}
}
}
}
int log2_max_frame_num_minus4 = ReadExponentialGolombCode();
int pic_order_cnt_type = ReadExponentialGolombCode();
if( pic_order_cnt_type == 0 )
{
int log2_max_pic_order_cnt_lsb_minus4 = ReadExponentialGolombCode();
}
else if( pic_order_cnt_type == 1 )
{
int delta_pic_order_always_zero_flag = ReadBit();
int offset_for_non_ref_pic = ReadSE();
int offset_for_top_to_bottom_field = ReadSE();
int num_ref_frames_in_pic_order_cnt_cycle = ReadExponentialGolombCode();
for( int i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++ )
{
ReadSE();
//sps->offset_for_ref_frame[ i ] = ReadSE();
}
}
int num_ref_frames = ReadExponentialGolombCode();
int gaps_in_frame_num_value_allowed_flag = ReadBit();
int pic_width_in_mbs_minus1 = ReadExponentialGolombCode();
int pic_height_in_map_units_minus1 = ReadExponentialGolombCode();
int frame_mbs_only_flag = ReadBit();
if( !frame_mbs_only_flag )
{
int mb_adaptive_frame_field_flag = ReadBit();
}
int direct_8x8_inference_flag = ReadBit();
int frame_cropping_flag = ReadBit();
if( frame_cropping_flag )
{
int frame_crop_left_offset = ReadExponentialGolombCode();
int frame_crop_right_offset = ReadExponentialGolombCode();
int frame_crop_top_offset = ReadExponentialGolombCode();
int frame_crop_bottom_offset = ReadExponentialGolombCode();
}
int vui_parameters_present_flag = ReadBit();
pStart++;
}
}SequenceParameterSet, *LPSequenceParameterSet;
C'est mon code d'analyser le SPS, mais se fait de fausses valeurs. pic_width_in_mbs_minus1 est de 5, et pic_height_in_map_units_minus1 est 1. En fait la vidéo est de 512 X 288px
Grâce
OriginalL'auteur Mr.Wang from Next Door | 2012-08-18
Vous devez vous connecter pour publier un commentaire.
Essayer ce codage. Cela fonctionne correctement, j'ai déjà testé avec le compilateur gcc.
Il suffit de régler votre chemin d'accès au fichier de compiler et de l'exécuter.
Code grande! En plus de la largeur et de la hauteur, Est-il de toute autre personne des renseignements peuvent être obtenus?
Oui, nous pouvons également obtenir de l'information sur les fps et aussi une autre information utile.
Vous êtes en soustrayant frame_crop_bottom_offset et frame_crop_top_offset de largeur.. Qui semble erroné
Vous regarde roulé la chnages sans tenir compte de la correction partielle dans edition révision - 3
OriginalL'auteur Pankaj Vavadiya
La
SPS
est (extrait):C'est 512x288 vidéo, voir les détails sur la façon de décoder les données ici: Récupérer les dimensions d'un H264Video flux
Vous semblez être en train de faire. Si vous avez ce NAL de flux d'octets avec le préfixe des codes, vous pourriez avaient à prendre soin de vérifier l'émulation octet de prévention de la première.
OriginalL'auteur Roman R.
J'ai rencontré une erreur avec au-dessus un exemple de code:
Devrait être:
Sinon, vous aurez une mauvaise résolution lorsque frame_cropping_flag est 1.
Espérons que cela aide quelqu'un d'autre.
OriginalL'auteur Alan Lu
Je peux confirmer que le code de Kaidul avec la correction de Alan Lu fonctionne parfaitement.
Notez que
Parse(const unsigned char * pStart, unsigned short nLen)
prend un h264 SPS nalu avec un décalage de 5 ( supprimer le '0 0 0 1' préfixe et le nal_unit_type octet )OriginalL'auteur Constantin Marcel