amy/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-11-15 02:54:55 -05:00
Code Issues 1 Projects Releases Packages Wiki Activity Actions
winamp/Src/mpeg4dec/mp4parse.c
Jef 20d28e80a5 Initial community commit
2024-09-24 14:54:57 +02:00

1109 lines
57 KiB
C
Raw Blame History

/* ///////////////////////////////////////////////////////////////////////
//
// INTEL CORPORATION PROPRIETARY INFORMATION
// This software is supplied under the terms of a license agreement or
// nondisclosure agreement with Intel Corporation and may not be copied
// or disclosed except in accordance with the terms of that agreement.
// Copyright (c) 2001-2007 Intel Corporation. All Rights Reserved.
//
// Description: Parses MPEG-4 headers
//
*/
#include "mp4def.h"
mp4_Status mp4_Parse_VisualObjectSequence(mp4_Info* pInfo)
{
pInfo->profile_and_level_indication = mp4_GetBits9(pInfo, 8);
if (pInfo->profile_and_level_indication != MP4_SIMPLE_PROFILE_LEVEL_1 &&
pInfo->profile_and_level_indication != MP4_SIMPLE_PROFILE_LEVEL_2 &&
pInfo->profile_and_level_indication != MP4_SIMPLE_PROFILE_LEVEL_3 &&
pInfo->profile_and_level_indication != MP4_SIMPLE_PROFILE_LEVEL_0 &&
pInfo->profile_and_level_indication != MP4_CORE_PROFILE_LEVEL_1 &&
pInfo->profile_and_level_indication != MP4_CORE_PROFILE_LEVEL_2 &&
pInfo->profile_and_level_indication != MP4_MAIN_PROFILE_LEVEL_2 &&
pInfo->profile_and_level_indication != MP4_MAIN_PROFILE_LEVEL_3 &&
pInfo->profile_and_level_indication != MP4_MAIN_PROFILE_LEVEL_4 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_REAL_TIME_SIMPLE_PROFILE_LEVEL_1 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_REAL_TIME_SIMPLE_PROFILE_LEVEL_2 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_REAL_TIME_SIMPLE_PROFILE_LEVEL_3 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_REAL_TIME_SIMPLE_PROFILE_LEVEL_4 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_CODING_EFFICIENCY_PROFILE_LEVEL_1 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_CODING_EFFICIENCY_PROFILE_LEVEL_2 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_CODING_EFFICIENCY_PROFILE_LEVEL_3 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_CODING_EFFICIENCY_PROFILE_LEVEL_4 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_CORE_PROFILE_LEVEL_1 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_CORE_PROFILE_LEVEL_2 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_0 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_1 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_2 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_3 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_4 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_5 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_3B) {
mp4_Error("Warning: Unsupported profile_and_level_indication");
if (pInfo->strictSyntaxCheck)
return MP4_STATUS_NOTSUPPORT;
}
if (pInfo->profile_and_level_indication != MP4_SIMPLE_PROFILE_LEVEL_1 &&
pInfo->profile_and_level_indication != MP4_SIMPLE_PROFILE_LEVEL_2 &&
pInfo->profile_and_level_indication != MP4_SIMPLE_PROFILE_LEVEL_3 &&
pInfo->profile_and_level_indication != MP4_SIMPLE_PROFILE_LEVEL_0 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_0 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_1 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_2 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_3 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_4 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_5 &&
pInfo->profile_and_level_indication != MP4_ADVANCED_SIMPLE_PROFILE_LEVEL_3B) {
mp4_Error("Warning: Some features of present profile_and_level_indication may be not supported");
}
return MP4_STATUS_OK;
}
mp4_Status mp4_Parse_VisualObject(mp4_Info* pInfo)
{
mp4_VisualObject *VO = &pInfo->VisualObject;
VO->is_identifier = mp4_GetBit(pInfo);
if (VO->is_identifier) {
VO->verid = mp4_GetBits9(pInfo, 4);
if ((VO->verid != 1) && (VO->verid != 2) && (VO->verid != 4) && (VO->verid != 5)) {
VO->verid = 1;
mp4_Error("Warning: Unsupported visual_object_verid");
//f if (pInfo->strictSyntaxCheck)
//f return MP4_STATUS_NOTSUPPORT;
}
VO->priority = mp4_GetBits9(pInfo, 3);
if (VO->priority == 0) {
mp4_Error("Warning: Wrong value of visual_object_priority");
//f if (pInfo->strictSyntaxCheck)
//f return MP4_STATUS_PARSE_ERROR;
}
} else
VO->verid = 1;
VO->type = mp4_GetBits9(pInfo, 4);
if (VO->type != MP4_VISUAL_OBJECT_TYPE_VIDEO) {
mp4_Error("Error: Unsupported object: visual_object_type != video ID");
return MP4_STATUS_NOTSUPPORT;
}
VO->VideoSignalType.video_format = MP4_VIDEO_FORMAT_UNSPECIFIED;
VO->VideoSignalType.video_range = 0;
VO->VideoSignalType.colour_primaries = MP4_VIDEO_COLORS_ITU_R_BT_709;
VO->VideoSignalType.transfer_characteristics = MP4_VIDEO_COLORS_ITU_R_BT_709;
VO->VideoSignalType.matrix_coefficients = MP4_VIDEO_COLORS_ITU_R_BT_709;
if (VO->type == MP4_VISUAL_OBJECT_TYPE_VIDEO || VO->type == MP4_VISUAL_OBJECT_TYPE_TEXTURE) {
VO->VideoSignalType.is_video_signal_type = mp4_GetBit(pInfo);
if (VO->VideoSignalType.is_video_signal_type) {
VO->VideoSignalType.video_format = mp4_GetBits9(pInfo, 3);
if (VO->VideoSignalType.video_format > MP4_VIDEO_FORMAT_UNSPECIFIED) {
mp4_Error("Warning: Wrong value of video_format");
//f if (pInfo->strictSyntaxCheck)
//f return MP4_STATUS_PARSE_ERROR;
}
VO->VideoSignalType.video_range = mp4_GetBit(pInfo);
VO->VideoSignalType.is_colour_description = mp4_GetBit(pInfo);
if (VO->VideoSignalType.is_colour_description) {
VO->VideoSignalType.colour_primaries = mp4_GetBits9(pInfo, 8);
if (VO->VideoSignalType.colour_primaries == MP4_VIDEO_COLORS_FORBIDDEN) {
mp4_Error("Error: Wrong value of colour_primaries");
if (pInfo->strictSyntaxCheck)
return MP4_STATUS_PARSE_ERROR;
}
if (VO->VideoSignalType.colour_primaries > MP4_VIDEO_COLORS_GENERIC_FILM) {
mp4_Error("Warning: Wrong value of colour_primaries");
//f if (pInfo->strictSyntaxCheck)
//f return MP4_STATUS_PARSE_ERROR;
}
VO->VideoSignalType.transfer_characteristics = mp4_GetBits9(pInfo, 8);
if (VO->VideoSignalType.transfer_characteristics == 0) {
mp4_Error("Error: Wrong value of transfer_characteristics");
if (pInfo->strictSyntaxCheck)
return MP4_STATUS_PARSE_ERROR;
}
if (VO->VideoSignalType.transfer_characteristics > 10) {
mp4_Error("Warning: Wrong value of transfer_characteristics");
//f if (pInfo->strictSyntaxCheck)
//f return MP4_STATUS_PARSE_ERROR;
}
VO->VideoSignalType.matrix_coefficients = mp4_GetBits9(pInfo, 8);
if (VO->VideoSignalType.matrix_coefficients == 0) {
mp4_Error("Error: Wrong value of matrix_coefficients");
if (pInfo->strictSyntaxCheck)
return MP4_STATUS_PARSE_ERROR;
}
if (VO->VideoSignalType.matrix_coefficients > 8) {
mp4_Error("Warning: Wrong value of matrix_coefficients");
//f if (pInfo->strictSyntaxCheck)
//f return MP4_STATUS_PARSE_ERROR;
}
}
}
}
return MP4_STATUS_OK;
}
static mp4_Status mp4_Parse_QuantMatrix(mp4_Info* pInfo, uint8_t pQM[64])
{
uint32_t code;
int32_t i;
for (i = 0; i < 64; i ++) {
code = mp4_GetBits9(pInfo, 8);
if (code == 0) break;
pQM[mp4_ClassicalZigzag[i]] = (uint8_t)code;
}
if (i > 0) {
code = pQM[mp4_ClassicalZigzag[i-1]];
for (; i < 64; i ++)
pQM[mp4_ClassicalZigzag[i]] = (uint8_t)code;
} else {
for (i = 1; i < 64; i ++)
pQM[mp4_ClassicalZigzag[i]] = (uint8_t)mp4_ClassicalZigzag[0];
}
return MP4_STATUS_OK;
}
mp4_Status mp4_Parse_VideoObject(mp4_Info* pInfo)
{
uint32_t code;
int32_t i;
mp4_VisualObject *VO = &pInfo->VisualObject;
mp4_VideoObject *VOL = &pInfo->VisualObject.VideoObject;
code = mp4_ShowBits(pInfo, 32);
// check short_video_start_marker
if ((code & (~0x3FF)) == 0x8000) {
VOL->short_video_header = 1;
VOL->quant_precision = 5;
VOL->shape = MP4_SHAPE_TYPE_RECTANGULAR;
VOL->obmc_disable = 1;
VOL->quant_type = 0;
VOL->resync_marker_disable = 1;
VOL->data_partitioned = 0;
VOL->reversible_vlc = 0;
VOL->VideoObjectPlane.rounding_type = 0;
VOL->VideoObjectPlane.fcode_forward = 1;
VOL->VideoObjectPlane.coded = 1;
VOL->interlaced = 0;
VOL->complexity_estimation_disable = 1;
VOL->scalability = 0;
VOL->not_8_bit = 0;
VOL->bits_per_pixel = 8;
VO->VideoSignalType.colour_primaries = 1;
VO->VideoSignalType.transfer_characteristics = 1;
VO->VideoSignalType.matrix_coefficients = 6;
VO->VideoObject.VideoObjectPlaneH263.source_format = (pInfo->bufptr[4] >> 2) & 0x7;
i = VO->VideoObject.VideoObjectPlaneH263.source_format - 1;
if (i < 0 || i > 4) {
mp4_Error("Error: Bad value for VideoPlaneWithShortHeader.source_format");
return MP4_STATUS_PARSE_ERROR;
}
VOL->width = mp4_H263_width[i];
VOL->height = mp4_H263_height[i];
VOL->VideoObjectPlaneH263.num_gobs_in_vop = mp4_H263_gobvop[i];
VOL->VideoObjectPlaneH263.num_macroblocks_in_gob = mp4_H263_mbgob[i];
VOL->VideoObjectPlaneH263.num_rows_in_gob = mp4_H263_rowgob[i];
VOL->vop_time_increment_resolution = 30000;
// VOL->VideoObjectPlane.time_increment = -1001;
VOL->VOLControlParameters.low_delay = 1;
return MP4_STATUS_OK;
}
if (code < 256 + MP4_VIDEO_OBJECT_LAYER_MIN_SC || code > 256 + MP4_VIDEO_OBJECT_LAYER_MAX_SC) {
mp4_Error("Error: Bad start code for VideoObjectLayer");
return MP4_STATUS_PARSE_ERROR;
}
mp4_FlushBits(pInfo, 32);
// video_object_start_code is founded
VOL->id = code & 15;
VOL->short_video_header = 0;
VOL->random_accessible_vol = mp4_GetBit(pInfo);
VOL->type_indication = mp4_GetBits9(pInfo, 8);
if (VOL->type_indication != MP4_VIDEO_OBJECT_TYPE_SIMPLE &&
VOL->type_indication != MP4_VIDEO_OBJECT_TYPE_CORE &&
VOL->type_indication != MP4_VIDEO_OBJECT_TYPE_MAIN &&
VOL->type_indication != MP4_VIDEO_OBJECT_TYPE_ADVANCED_REAL_TIME_SIMPLE &&
VOL->type_indication != MP4_VIDEO_OBJECT_TYPE_ADVANCED_CODING_EFFICIENCY &&
VOL->type_indication != MP4_VIDEO_OBJECT_TYPE_ADVANCED_SIMPLE) {
mp4_Error("Warning: Unsupported video_object_type_indication, some features may be not supported");
//f if (pInfo->strictSyntaxCheck)
//f return MP4_STATUS_NOTSUPPORT;
}
VOL->is_identifier = mp4_GetBit(pInfo);
if (VOL->is_identifier) {
VOL->verid = mp4_GetBits9(pInfo, 4);
if ((VOL->verid != 1) && (VOL->verid != 2) && (VOL->verid != 4) && (VOL->verid != 5)) {
mp4_Error("Warning: Unsupported video_object_layer_verid");
VOL->verid = VO->verid;
//f if (pInfo->strictSyntaxCheck)
//f return MP4_STATUS_NOTSUPPORT;
}
VOL->priority = mp4_GetBits9(pInfo, 3);
if (VOL->priority == 0) {
mp4_Error("Warning: Wrong value of video_object_layer_priority");
//f if (pInfo->strictSyntaxCheck)
//f return MP4_STATUS_PARSE_ERROR;
}
} else
VOL->verid = VO->verid;
VOL->aspect_ratio_info = mp4_GetBits9(pInfo, 4);
if (VOL->aspect_ratio_info == MP4_ASPECT_RATIO_FORBIDDEN) {
mp4_Error("Error: Wrong value of aspect_ratio_info");
if (pInfo->strictSyntaxCheck)
return MP4_STATUS_PARSE_ERROR;
}
if (VOL->aspect_ratio_info > MP4_ASPECT_RATIO_40_33 && VOL->aspect_ratio_info < MP4_ASPECT_RATIO_EXTPAR) {
mp4_Error("Warning: Wrong value of aspect_ratio_info");
//f if (pInfo->strictSyntaxCheck)
//f return MP4_STATUS_PARSE_ERROR;
}
if (VOL->aspect_ratio_info == MP4_ASPECT_RATIO_EXTPAR) {
VOL->aspect_ratio_info_par_width = mp4_GetBits9(pInfo, 8);
if (VOL->aspect_ratio_info_par_width == 0) {
mp4_Error("Error: Wrong value of par_width");
if (pInfo->strictSyntaxCheck)
return MP4_STATUS_PARSE_ERROR;
}
VOL->aspect_ratio_info_par_height = mp4_GetBits9(pInfo, 8);
if (VOL->aspect_ratio_info_par_height == 0) {
mp4_Error("Error: Wrong value of par_height");
if (pInfo->strictSyntaxCheck)
return MP4_STATUS_PARSE_ERROR;
}
}
VOL->is_vol_control_parameters = mp4_GetBit(pInfo);
if (VOL->type_indication == MP4_VIDEO_OBJECT_TYPE_SIMPLE || VOL->type_indication != MP4_VIDEO_OBJECT_TYPE_ADVANCED_REAL_TIME_SIMPLE)
VOL->VOLControlParameters.low_delay = 1;
if (VOL->is_vol_control_parameters) {
VOL->VOLControlParameters.chroma_format = mp4_GetBits9(pInfo, 2);
if (VOL->VOLControlParameters.chroma_format != MP4_CHROMA_FORMAT_420) {
mp4_Error("Error: chroma_format != 4:2:0");
return MP4_STATUS_PARSE_ERROR;
}
VOL->VOLControlParameters.low_delay = mp4_GetBit(pInfo);
VOL->VOLControlParameters.vbv_parameters = mp4_GetBit(pInfo);
if (VOL->VOLControlParameters.vbv_parameters) {
VOL->VOLControlParameters.bit_rate = mp4_GetBits(pInfo, 15) << 15;
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
VOL->VOLControlParameters.bit_rate += mp4_GetBits(pInfo, 15);
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
if (VOL->VOLControlParameters.bit_rate == 0) {
mp4_Error("Error: vbv_parameters bit_rate == 0");
return MP4_STATUS_PARSE_ERROR;
}
VOL->VOLControlParameters.vbv_buffer_size = mp4_GetBits(pInfo, 15) << 3;
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
VOL->VOLControlParameters.vbv_buffer_size += mp4_GetBits9(pInfo, 3);
if (VOL->VOLControlParameters.vbv_buffer_size == 0) {
mp4_Error("Error: vbv_parameters vbv_buffer_size == 0");
return MP4_STATUS_PARSE_ERROR;
}
VOL->VOLControlParameters.vbv_occupancy = mp4_GetBits(pInfo, 11) << 15;
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
VOL->VOLControlParameters.vbv_occupancy += mp4_GetBits(pInfo, 15);
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
}
}
VOL->shape = mp4_GetBits9(pInfo, 2);
if (VOL->shape != MP4_SHAPE_TYPE_RECTANGULAR) {
mp4_Error("Error: video_object_layer_shape != rectangular (not supported)");
return MP4_STATUS_PARSE_ERROR;
}
if (VOL->verid != 1 && VOL->shape == MP4_SHAPE_TYPE_GRAYSCALE) {
VOL->shape_extension = mp4_GetBits9(pInfo, 4);
if (VOL->shape_extension >= MP4_SHAPE_EXT_NUM) {
mp4_Error("Error: wrong value of video_object_layer_shape_extension");
return MP4_STATUS_PARSE_ERROR;
}
} else
VOL->shape_extension = MP4_SHAPE_EXT_NUM;
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
VOL->vop_time_increment_resolution = mp4_GetBits(pInfo, 16);
if (VOL->vop_time_increment_resolution == 0) {
mp4_Error("Error: wrong value of vop_time_increment_resolution");
return MP4_STATUS_PARSE_ERROR;
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
// define number bits in vop_time_increment_resolution
code = VOL->vop_time_increment_resolution - 1;
i = 0;
do {
code >>= 1;
i ++;
} while (code);
VOL->vop_time_increment_resolution_bits = i;
VOL->fixed_vop_rate = mp4_GetBit(pInfo);
if (VOL->fixed_vop_rate) {
VOL->fixed_vop_time_increment = mp4_GetBits(pInfo, VOL->vop_time_increment_resolution_bits);
if (VOL->fixed_vop_time_increment == 0) {
mp4_Error("Error: wrong value of fixed_vop_time_increment");
return MP4_STATUS_PARSE_ERROR;
}
}
if (VOL->shape != MP4_SHAPE_TYPE_BINARYONLY) {
if (VOL->shape == MP4_SHAPE_TYPE_RECTANGULAR) {
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
VOL->width = mp4_GetBits(pInfo, 13);
if (VOL->width == 0) {
mp4_Error("Error: wrong value of video_object_layer_width");
return MP4_STATUS_PARSE_ERROR;
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
VOL->height = mp4_GetBits(pInfo, 13);
if (VOL->height == 0) {
mp4_Error("Error: wrong value of video_object_layer_height");
return MP4_STATUS_PARSE_ERROR;
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
}
VOL->interlaced = mp4_GetBit(pInfo);
VOL->obmc_disable = mp4_GetBit(pInfo);
VOL->sprite_enable = mp4_GetBits9(pInfo, VOL->verid != 1 ? 2 : 1);
if (VOL->sprite_enable == MP4_SPRITE_STATIC || VOL->sprite_enable == MP4_SPRITE_GMC) {
if (VOL->sprite_enable == MP4_SPRITE_STATIC) {
VOL->sprite_width = mp4_GetBits(pInfo, 13);
if (VOL->sprite_width == 0) {
mp4_Error("Error: wrong value of sprite_width");
return MP4_STATUS_PARSE_ERROR;
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
VOL->sprite_height = mp4_GetBits(pInfo, 13);
if (VOL->sprite_height == 0) {
mp4_Error("Error: wrong value of sprite_height");
return MP4_STATUS_PARSE_ERROR;
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
VOL->sprite_left_coordinate = mp4_GetBits(pInfo, 13);
VOL->sprite_left_coordinate <<= (32 - 13);
VOL->sprite_left_coordinate >>= (32 - 13);
if (VOL->sprite_left_coordinate & 1) {
mp4_Error("Error: sprite_left_coordinate must be divisible by 2");
return MP4_STATUS_PARSE_ERROR;
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
VOL->sprite_top_coordinate = mp4_GetBits(pInfo, 13);
VOL->sprite_top_coordinate <<= (32 - 13);
VOL->sprite_top_coordinate >>= (32 - 13);
if (VOL->sprite_top_coordinate & 1) {
mp4_Error("Error: sprite_top_coordinate must be divisible by 2");
return MP4_STATUS_PARSE_ERROR;
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
}
VOL->sprite_warping_points = mp4_GetBits9(pInfo, 6);
if (VOL->sprite_warping_points > 4 || (VOL->sprite_warping_points == 4 && VOL->sprite_enable == MP4_SPRITE_GMC)) {
mp4_Error("Error: bad no_of_sprite_warping_points");
return MP4_STATUS_PARSE_ERROR;
}
VOL->sprite_warping_accuracy = mp4_GetBits9(pInfo, 2);
VOL->sprite_brightness_change = mp4_GetBit(pInfo);
if (VOL->sprite_enable == MP4_SPRITE_GMC) {
if (VOL->sprite_brightness_change) {
mp4_Error("Error: sprite_brightness_change should be 0 for GMC sprites");
return MP4_STATUS_PARSE_ERROR;
}
}
if (VOL->sprite_enable != MP4_SPRITE_GMC) {
VOL->low_latency_sprite_enable = mp4_GetBit(pInfo);
if (VOL->low_latency_sprite_enable) {
mp4_Error("Error: low_latency_sprite is not supported");
return MP4_STATUS_PARSE_ERROR;
}
}
}
if (VOL->verid != 1 && VOL->shape != MP4_SHAPE_TYPE_RECTANGULAR) {
VOL->sadct_disable = mp4_GetBit(pInfo);
if (!VOL->sadct_disable) {
mp4_Error("Error: Shape Adaptive DCT is not supported");
return MP4_STATUS_PARSE_ERROR;
}
}
VOL->not_8_bit = mp4_GetBit(pInfo);
if (VOL->not_8_bit) {
mp4_Error("Error: only 8-bits data is supported");
return MP4_STATUS_PARSE_ERROR;
}
if (VOL->not_8_bit) {
VOL->quant_precision = mp4_GetBits9(pInfo, 4);
if (VOL->quant_precision < 3 || VOL->quant_precision > 9) {
mp4_Error("Error: quant_precision must be in range [3; 9]");
return MP4_STATUS_PARSE_ERROR;
}
VOL->bits_per_pixel = mp4_GetBits9(pInfo, 4);
if (VOL->bits_per_pixel < 4 || VOL->bits_per_pixel > 12) {
mp4_Error("Error: bits_per_pixel must be in range [4; 12]");
return MP4_STATUS_PARSE_ERROR;
}
} else {
VOL->quant_precision = 5;
VOL->bits_per_pixel = 8;
}
if (VOL->shape == MP4_SHAPE_TYPE_GRAYSCALE) {
VOL->no_gray_quant_update = mp4_GetBit(pInfo);
VOL->composition_method = mp4_GetBit(pInfo);
VOL->linear_composition = mp4_GetBit(pInfo);
}
VOL->quant_type = mp4_GetBit(pInfo);
if (VOL->quant_type) {
VOL->load_intra_quant_mat = mp4_GetBit(pInfo);
if (VOL->load_intra_quant_mat) {
if (mp4_Parse_QuantMatrix(pInfo, VOL->intra_quant_mat) != MP4_STATUS_OK)
return MP4_STATUS_PARSE_ERROR;
} else
ippsCopy_8u(mp4_DefaultIntraQuantMatrix, VOL->intra_quant_mat, 64);
VOL->load_nonintra_quant_mat = mp4_GetBit(pInfo);
if (VOL->load_nonintra_quant_mat) {
if (mp4_Parse_QuantMatrix(pInfo, VOL->nonintra_quant_mat) != MP4_STATUS_OK)
return MP4_STATUS_PARSE_ERROR;
} else
ippsCopy_8u(mp4_DefaultNonIntraQuantMatrix, VOL->nonintra_quant_mat, 64);
if (VOL->shape == MP4_SHAPE_TYPE_GRAYSCALE) {
int32_t ac, i;
ac = mp4_aux_comp_count[VOL->shape_extension];
for (i = 0; i < ac; i ++) {
VOL->load_intra_quant_mat_grayscale[i] = mp4_GetBit(pInfo);
if (VOL->load_intra_quant_mat_grayscale[i]) {
if (mp4_Parse_QuantMatrix(pInfo, VOL->intra_quant_mat_grayscale[i]) != MP4_STATUS_OK)
return MP4_STATUS_PARSE_ERROR;
} else
ippsCopy_8u(mp4_DefaultIntraQuantMatrix, VOL->intra_quant_mat_grayscale[i], 64);
VOL->load_nonintra_quant_mat_grayscale[i] = mp4_GetBit(pInfo);
if (VOL->load_nonintra_quant_mat_grayscale[i]) {
if (mp4_Parse_QuantMatrix(pInfo, VOL->nonintra_quant_mat_grayscale[i]) != MP4_STATUS_OK)
return MP4_STATUS_PARSE_ERROR;
} else
ippsCopy_8u(mp4_DefaultNonIntraQuantMatrix, VOL->nonintra_quant_mat_grayscale[i], 64);
}
}
}
if (VOL->verid != 1)
VOL->quarter_sample = mp4_GetBit(pInfo);
VOL->complexity_estimation_disable = mp4_GetBit(pInfo);
if (!VOL->complexity_estimation_disable) {
VOL->ComplexityEstimation.estimation_method = mp4_GetBits9(pInfo, 2);
if (VOL->ComplexityEstimation.estimation_method <= 1) {
VOL->ComplexityEstimation.shape_complexity_estimation_disable = mp4_GetBit(pInfo);
if (!VOL->ComplexityEstimation.shape_complexity_estimation_disable) {
VOL->ComplexityEstimation.opaque = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.transparent = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.intra_cae = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.inter_cae = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.no_update = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.upsampling = mp4_GetBit(pInfo);
}
VOL->ComplexityEstimation.texture_complexity_estimation_set_1_disable = mp4_GetBit(pInfo);
if (!VOL->ComplexityEstimation.texture_complexity_estimation_set_1_disable) {
VOL->ComplexityEstimation.intra_blocks = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.inter_blocks = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.inter4v_blocks = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.not_coded_blocks = mp4_GetBit(pInfo);
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
VOL->ComplexityEstimation.texture_complexity_estimation_set_2_disable = mp4_GetBit(pInfo);
if (!VOL->ComplexityEstimation.texture_complexity_estimation_set_2_disable) {
VOL->ComplexityEstimation.dct_coefs = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.dct_lines = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.vlc_symbols = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.vlc_bits = mp4_GetBit(pInfo);
}
VOL->ComplexityEstimation.motion_compensation_complexity_disable = mp4_GetBit(pInfo);
if (!VOL->ComplexityEstimation.motion_compensation_complexity_disable) {
VOL->ComplexityEstimation.apm = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.npm = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.interpolate_mc_q = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.forw_back_mc_q = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.halfpel2 = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.halfpel4 = mp4_GetBit(pInfo);
}
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
if (VOL->ComplexityEstimation.estimation_method == 1) {
// verid != 1
VOL->ComplexityEstimation.version2_complexity_estimation_disable = mp4_GetBit(pInfo);
if (!VOL->ComplexityEstimation.version2_complexity_estimation_disable) {
VOL->ComplexityEstimation.sadct = mp4_GetBit(pInfo);
VOL->ComplexityEstimation.quarterpel = mp4_GetBit(pInfo);
}
}
}
VOL->resync_marker_disable = mp4_GetBit(pInfo);
VOL->data_partitioned = mp4_GetBit(pInfo);
//f GrayScale Shapes does not support data_part
if (VOL->data_partitioned)
VOL->reversible_vlc = mp4_GetBit(pInfo);
if (VOL->verid != 1) {
VOL->newpred_enable = mp4_GetBit(pInfo);
if (VOL->newpred_enable) {
VOL->requested_upstream_message_type = mp4_GetBits9(pInfo, 2);
VOL->newpred_segment_type = mp4_GetBit(pInfo);
mp4_Error("Warning: NEWPRED mode is not fully supported");
//f return MP4_STATUS_PARSE_ERROR;
}
VOL->reduced_resolution_vop_enable = mp4_GetBit(pInfo);
if (VOL->reduced_resolution_vop_enable) {
mp4_Error("Error: Reduced Resolution VOP is not supported");
return MP4_STATUS_PARSE_ERROR;
}
}
VOL->scalability = mp4_GetBit(pInfo);
if (VOL->scalability) {
mp4_Error("Error: VOL scalability is not supported");
return MP4_STATUS_PARSE_ERROR;
}
} else {
if (VOL->verid != 1) {
VOL->scalability = mp4_GetBit(pInfo);
if (VOL->scalability) {
mp4_Error("Error: VOL scalability is not supported");
return MP4_STATUS_PARSE_ERROR;
}
}
VOL->resync_marker_disable = mp4_GetBit(pInfo);
}
VOL->VideoObjectPlane.sprite_transmit_mode = MP4_SPRITE_TRANSMIT_MODE_PIECE;
#if 0
{
uint8_t *sbp = pInfo->bufptr;
int32_t v, b, i;
if (mp4_SeekStartCodeValue(pInfo, MP4_USER_DATA_SC)) {
if (pInfo->bufptr[0] == 'D' && pInfo->bufptr[1] == 'i' && pInfo->bufptr[2] == 'v' && pInfo->bufptr[3] == 'X') {
pInfo->ftype = 2;
v = (pInfo->bufptr[4] - '0') * 100 + (pInfo->bufptr[5] - '0') * 10 + (pInfo->bufptr[6] - '0');
if (v < 503)
pInfo->ftype_f = 1;
else if (v == 503) {
i = 8;
b = 0;
while (pInfo->bufptr[i] != 0) {
if (pInfo->bufptr[i] >= '0' && pInfo->bufptr[i] <= '9')
b = b * 10 + (pInfo->bufptr[i] - '0');
i ++;
}
pInfo->ftype_f = (b < 959) ? 1 : 0;
} else
pInfo->ftype_f = 0;
}
}
pInfo->bufptr = sbp;
}
#else
{
uint8_t *sbp = pInfo->bufptr;
if (mp4_SeekStartCodeValue(pInfo, MP4_USER_DATA_SC)) {
if (pInfo->bufptr[0] == 'D' && pInfo->bufptr[1] == 'i' && pInfo->bufptr[2] == 'v' && pInfo->bufptr[3] == 'X') {
pInfo->ftype = 2;
pInfo->ftype_f = 1;
}
}
pInfo->bufptr = sbp;
}
#endif
return MP4_STATUS_OK;
}
/*static */mp4_Status mp4_Sprite_Trajectory(mp4_Info* pInfo) {
int32_t i, dmv_code, dmv_length, fb;
uint32_t code;
for (i = 0; i < pInfo->VisualObject.VideoObject.sprite_warping_points; i ++) {
code = mp4_ShowBits9(pInfo, 3);
if (code == 7) {
mp4_FlushBits(pInfo, 3);
code = mp4_ShowBits9(pInfo, 9);
fb = 1;
while (code & 256) {
code <<= 1;
fb ++;
}
if (fb > 9) {
mp4_Error("Error when decode sprite_trajectory");
return MP4_STATUS_PARSE_ERROR;
}
dmv_length = fb + 5;
} else {
fb = (code <= 1) ? 2 : 3;
dmv_length = code - 1;
}
mp4_FlushBits(pInfo, fb);
if (dmv_length <= 0)
dmv_code = 0;
else {
dmv_code = mp4_GetBits(pInfo, dmv_length);
if ((dmv_code & (1 << (dmv_length - 1))) == 0)
dmv_code -= (1 << dmv_length) - 1;
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
pInfo->VisualObject.VideoObject.VideoObjectPlane.warping_mv_code_du[i] = dmv_code;
code = mp4_ShowBits9(pInfo, 3);
if (code == 7) {
mp4_FlushBits(pInfo, 3);
code = mp4_ShowBits9(pInfo, 9);
fb = 1;
while (code & 256) {
code <<= 1;
fb ++;
}
if (fb > 9) {
mp4_Error("Error when decode sprite_trajectory");
return MP4_STATUS_PARSE_ERROR;
}
dmv_length = fb + 5;
} else {
fb = (code <= 1) ? 2 : 3;
dmv_length = code - 1;
}
mp4_FlushBits(pInfo, fb);
if (dmv_length <= 0)
dmv_code = 0;
else {
dmv_code = mp4_GetBits(pInfo, dmv_length);
if ((dmv_code & (1 << (dmv_length - 1))) == 0)
dmv_code -= (1 << dmv_length) - 1;
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
pInfo->VisualObject.VideoObject.VideoObjectPlane.warping_mv_code_dv[i] = dmv_code;
}
return MP4_STATUS_OK;
}
mp4_Status mp4_Parse_GroupOfVideoObjectPlane(mp4_Info* pInfo)
{
uint32_t hour, min, sec;
hour = mp4_GetBits9(pInfo, 5);
min = mp4_GetBits9(pInfo, 6);
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
sec = mp4_GetBits9(pInfo, 6);
pInfo->VisualObject.VideoObject.GroupOfVideoObjectPlane.time_code = sec + min * 60 + hour * 3600;
pInfo->VisualObject.VideoObject.GroupOfVideoObjectPlane.time_code *= pInfo->VisualObject.VideoObject.vop_time_increment_resolution;
pInfo->VisualObject.VideoObject.GroupOfVideoObjectPlane.closed_gov = mp4_GetBit(pInfo);
pInfo->VisualObject.VideoObject.GroupOfVideoObjectPlane.broken_link = mp4_GetBit(pInfo);
return MP4_STATUS_OK;
}
mp4_Status mp4_Parse_VideoObjectPlane(mp4_Info* pInfo)
{
uint32_t code;
mp4_VideoObject *VOL = &pInfo->VisualObject.VideoObject;
mp4_VideoObjectPlane *VOP = &pInfo->VisualObject.VideoObject.VideoObjectPlane;
mp4_VideoObjectPlaneH263 *VOPSH = &pInfo->VisualObject.VideoObject.VideoObjectPlaneH263;
if (VOL->short_video_header) {
code = mp4_GetBits9(pInfo, 6); // read rest bits of short_video_start_marker
VOPSH->temporal_reference = mp4_GetBits9(pInfo, 8);
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
code = mp4_GetBit(pInfo); // zero_bit
VOPSH->split_screen_indicator = mp4_GetBit(pInfo);
VOPSH->document_camera_indicator = mp4_GetBit(pInfo);
VOPSH->full_picture_freeze_release = mp4_GetBit(pInfo);
VOPSH->source_format = mp4_GetBits9(pInfo, 3);
if (VOPSH->source_format == 0 || VOPSH->source_format > 5) {
mp4_Error("Error: Bad value for VideoPlaneWithShortHeader.source_format");
return MP4_STATUS_PARSE_ERROR;
}
VOPSH->picture_coding_type = mp4_GetBit(pInfo);
VOP->coding_type = VOPSH->picture_coding_type;
code = mp4_GetBits9(pInfo, 4); // four_reserved_zero_bits
VOPSH->vop_quant = mp4_GetBits9(pInfo, 5);
code = mp4_GetBit(pInfo); // zero_bit
for (;;) {
code = mp4_GetBit(pInfo); // pei
if (!code)
break;
code = mp4_GetBits9(pInfo, 8); // psupp
}
return MP4_STATUS_OK;
}
VOP->coding_type = mp4_GetBits9(pInfo, 2);
if (((VOP->coding_type != MP4_VOP_TYPE_I) && (pInfo->noPVOPs)) || ((VOP->coding_type == MP4_VOP_TYPE_B) && (pInfo->noBVOPs))) {
mp4_Error("Error: Bad vop_coding_type");
return MP4_STATUS_PARSE_ERROR;
}
VOP->modulo_time_base = 0;
do {
code = mp4_GetBit(pInfo);
VOP->modulo_time_base += code;
} while (code);
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
if (VOL->vop_time_increment_resolution_bits != 0 ) {
VOP->time_increment = mp4_GetBits(pInfo, VOL->vop_time_increment_resolution_bits);
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
VOP->coded = mp4_GetBit(pInfo);
if (!VOP->coded)
return MP4_STATUS_OK;
if (VOL->newpred_enable) {
int vop_id_length = VOL->vop_time_increment_resolution_bits + 3;
if (vop_id_length > 15)
vop_id_length = 15;
VOP->vop_id = mp4_GetBits(pInfo, vop_id_length);
VOP->vop_id_for_prediction_indication = mp4_GetBit(pInfo);
if (VOP->vop_id_for_prediction_indication)
VOP->vop_id_for_prediction = mp4_GetBits(pInfo, vop_id_length);
if (!mp4_GetMarkerBit(pInfo))
return MP4_STATUS_PARSE_ERROR;
}
if (VOL->shape != MP4_SHAPE_TYPE_BINARYONLY && (VOP->coding_type == MP4_VOP_TYPE_P ||
(VOP->coding_type == MP4_VOP_TYPE_S && VOL->sprite_enable == MP4_SPRITE_GMC)))
VOP->rounding_type = mp4_GetBit(pInfo);
if (VOL->reduced_resolution_vop_enable && VOL->shape == MP4_SHAPE_TYPE_RECTANGULAR &&
(VOP->coding_type == MP4_VOP_TYPE_I || VOP->coding_type == MP4_VOP_TYPE_P)) {
VOP->reduced_resolution = mp4_GetBit(pInfo);
if (VOP->reduced_resolution) {
mp4_Error("Error: Reduced Resolution VOP is not supported");
return MP4_STATUS_PARSE_ERROR;
}
}
if (VOL->shape != MP4_SHAPE_TYPE_RECTANGULAR) {
if (!(VOL->sprite_enable == MP4_SPRITE_STATIC && VOP->coding_type == MP4_VOP_TYPE_I)) {
VOP->vop_width = mp4_GetBits(pInfo, 13);
if (VOP->vop_width == 0) {
mp4_Error("Error: wrong value of vop_width");
return MP4_STATUS_PARSE_ERROR;
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
VOP->vop_height = mp4_GetBits(pInfo, 13);
if (VOP->vop_height == 0) {
mp4_Error("Error: wrong value of vop_height");
return MP4_STATUS_PARSE_ERROR;
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
VOP->vop_horizontal_mc_spatial_ref = mp4_GetBits(pInfo, 13);
VOP->vop_horizontal_mc_spatial_ref <<= (32 - 13);
VOP->vop_horizontal_mc_spatial_ref >>= (32 - 13);
if (VOP->vop_horizontal_mc_spatial_ref & 1) {
mp4_Error("Error: vop_horizontal_mc_spatial_ref must be divisible by 2");
return MP4_STATUS_PARSE_ERROR;
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
VOP->vop_vertical_mc_spatial_ref = mp4_GetBits(pInfo, 13);
VOP->vop_vertical_mc_spatial_ref <<= (32 - 13);
VOP->vop_vertical_mc_spatial_ref >>= (32 - 13);
if (VOP->vop_vertical_mc_spatial_ref & 1) {
mp4_Error("Error: vop_vertical_mc_spatial_ref must be divisible by 2");
return MP4_STATUS_PARSE_ERROR;
}
if (!mp4_GetMarkerBit(pInfo)) return MP4_STATUS_PARSE_ERROR;
}
//f if ((VOL->shape != MP4_SHAPE_TYPE_BINARYONLY) && VOL->scalability && enhancement_type)
//f background_composition = mp4_GetBit(pInfo);
VOP->change_conv_ratio_disable = mp4_GetBit(pInfo);
VOP->vop_constant_alpha = mp4_GetBit(pInfo);
if (VOP->vop_constant_alpha)
VOP->vop_constant_alpha_value = mp4_GetBits9(pInfo, 8);
else
VOP->vop_constant_alpha_value = 255;
}
if (VOL->shape != MP4_SHAPE_TYPE_BINARYONLY) {
if (!VOL->complexity_estimation_disable) {
if (VOL->ComplexityEstimation.estimation_method == 0) {
if (VOP->coding_type == MP4_VOP_TYPE_I) {
if (VOL->ComplexityEstimation.opaque) VOL->ComplexityEstimation.dcecs_opaque = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.transparent) VOL->ComplexityEstimation.dcecs_transparent = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.intra_cae) VOL->ComplexityEstimation.dcecs_intra_cae = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.inter_cae) VOL->ComplexityEstimation.dcecs_inter_cae = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.no_update) VOL->ComplexityEstimation.dcecs_no_update = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.upsampling) VOL->ComplexityEstimation.dcecs_upsampling = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.intra_blocks) VOL->ComplexityEstimation.dcecs_intra_blocks = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.not_coded_blocks) VOL->ComplexityEstimation.dcecs_not_coded_blocks = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.dct_coefs) VOL->ComplexityEstimation.dcecs_dct_coefs = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.dct_lines) VOL->ComplexityEstimation.dcecs_dct_lines = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.vlc_symbols) VOL->ComplexityEstimation.dcecs_vlc_symbols = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.vlc_bits) VOL->ComplexityEstimation.dcecs_vlc_bits = mp4_GetBits9(pInfo, 4);
if (VOL->ComplexityEstimation.sadct) VOL->ComplexityEstimation.dcecs_sadct = mp4_GetBits9(pInfo, 8);
}
if (VOP->coding_type == MP4_VOP_TYPE_P) {
if (VOL->ComplexityEstimation.opaque) VOL->ComplexityEstimation.dcecs_opaque = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.transparent) VOL->ComplexityEstimation.dcecs_transparent = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.intra_cae) VOL->ComplexityEstimation.dcecs_intra_cae = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.inter_cae) VOL->ComplexityEstimation.dcecs_inter_cae = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.no_update) VOL->ComplexityEstimation.dcecs_no_update = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.upsampling) VOL->ComplexityEstimation.dcecs_upsampling = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.intra_blocks) VOL->ComplexityEstimation.dcecs_intra_blocks = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.not_coded_blocks) VOL->ComplexityEstimation.dcecs_not_coded_blocks = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.dct_coefs) VOL->ComplexityEstimation.dcecs_dct_coefs = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.dct_lines) VOL->ComplexityEstimation.dcecs_dct_lines = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.vlc_symbols) VOL->ComplexityEstimation.dcecs_vlc_symbols = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.vlc_bits) VOL->ComplexityEstimation.dcecs_vlc_bits = mp4_GetBits9(pInfo, 4);
if (VOL->ComplexityEstimation.inter_blocks) VOL->ComplexityEstimation.dcecs_inter_blocks = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.inter4v_blocks) VOL->ComplexityEstimation.dcecs_inter4v_blocks = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.apm) VOL->ComplexityEstimation.dcecs_apm = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.npm) VOL->ComplexityEstimation.dcecs_npm = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.forw_back_mc_q) VOL->ComplexityEstimation.dcecs_forw_back_mc_q = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.halfpel2) VOL->ComplexityEstimation.dcecs_halfpel2 = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.halfpel4) VOL->ComplexityEstimation.dcecs_halfpel4 = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.sadct) VOL->ComplexityEstimation.dcecs_sadct = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.quarterpel) VOL->ComplexityEstimation.dcecs_quarterpel = mp4_GetBits9(pInfo, 8);
}
if (VOP->coding_type == MP4_VOP_TYPE_B) {
if (VOL->ComplexityEstimation.opaque) VOL->ComplexityEstimation.dcecs_opaque = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.transparent) VOL->ComplexityEstimation.dcecs_transparent = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.intra_cae) VOL->ComplexityEstimation.dcecs_intra_cae = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.inter_cae) VOL->ComplexityEstimation.dcecs_inter_cae = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.no_update) VOL->ComplexityEstimation.dcecs_no_update = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.upsampling) VOL->ComplexityEstimation.dcecs_upsampling = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.intra_blocks) VOL->ComplexityEstimation.dcecs_intra_blocks = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.not_coded_blocks) VOL->ComplexityEstimation.dcecs_not_coded_blocks = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.dct_coefs) VOL->ComplexityEstimation.dcecs_dct_coefs = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.dct_lines) VOL->ComplexityEstimation.dcecs_dct_lines = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.vlc_symbols) VOL->ComplexityEstimation.dcecs_vlc_symbols = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.vlc_bits) VOL->ComplexityEstimation.dcecs_vlc_bits = mp4_GetBits9(pInfo, 4);
if (VOL->ComplexityEstimation.inter_blocks) VOL->ComplexityEstimation.dcecs_inter_blocks = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.inter4v_blocks) VOL->ComplexityEstimation.dcecs_inter4v_blocks = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.apm) VOL->ComplexityEstimation.dcecs_apm = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.npm) VOL->ComplexityEstimation.dcecs_npm = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.forw_back_mc_q) VOL->ComplexityEstimation.dcecs_forw_back_mc_q = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.halfpel2) VOL->ComplexityEstimation.dcecs_halfpel2 = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.halfpel4) VOL->ComplexityEstimation.dcecs_halfpel4 = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.interpolate_mc_q) VOL->ComplexityEstimation.dcecs_interpolate_mc_q = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.sadct) VOL->ComplexityEstimation.dcecs_sadct = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.quarterpel) VOL->ComplexityEstimation.dcecs_quarterpel = mp4_GetBits9(pInfo, 8);
}
if (VOP->coding_type == MP4_VOP_TYPE_S && VOL->sprite_enable == MP4_SPRITE_STATIC) {
if (VOL->ComplexityEstimation.intra_blocks) VOL->ComplexityEstimation.dcecs_intra_blocks = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.not_coded_blocks) VOL->ComplexityEstimation.dcecs_not_coded_blocks = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.dct_coefs) VOL->ComplexityEstimation.dcecs_dct_coefs = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.dct_lines) VOL->ComplexityEstimation.dcecs_dct_lines = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.vlc_symbols) VOL->ComplexityEstimation.dcecs_vlc_symbols = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.vlc_bits) VOL->ComplexityEstimation.dcecs_vlc_bits = mp4_GetBits9(pInfo, 4);
if (VOL->ComplexityEstimation.inter_blocks) VOL->ComplexityEstimation.dcecs_inter_blocks = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.inter4v_blocks) VOL->ComplexityEstimation.dcecs_inter4v_blocks = mp4_GetBits(pInfo, 8);
if (VOL->ComplexityEstimation.apm) VOL->ComplexityEstimation.dcecs_apm = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.npm) VOL->ComplexityEstimation.dcecs_npm = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.forw_back_mc_q) VOL->ComplexityEstimation.dcecs_forw_back_mc_q = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.halfpel2) VOL->ComplexityEstimation.dcecs_halfpel2 = mp4_GetBits9(pInfo, 8);
if (VOL->ComplexityEstimation.halfpel4) VOL->ComplexityEstimation.dcecs_halfpel4 = mp4_GetBits(pInfo, 8);
if (VOL->ComplexityEstimation.interpolate_mc_q) VOL->ComplexityEstimation.dcecs_interpolate_mc_q = mp4_GetBits9(pInfo, 8);
}
}
}
VOP->intra_dc_vlc_thr = mp4_GetBits9(pInfo, 3);
if (VOL->interlaced) {
VOP->top_field_first = mp4_GetBit(pInfo);
VOP->alternate_vertical_scan_flag = mp4_GetBit(pInfo);
}
}
if ((VOL->sprite_enable == MP4_SPRITE_STATIC || VOL->sprite_enable == MP4_SPRITE_GMC) && VOP->coding_type == MP4_VOP_TYPE_S) {
if (VOL->sprite_warping_points > 0)
if (mp4_Sprite_Trajectory(pInfo) != MP4_STATUS_OK)
return MP4_STATUS_PARSE_ERROR;
if (VOL->sprite_brightness_change) {
code = mp4_ShowBits9(pInfo, 4);
if (code == 15) {
mp4_FlushBits(pInfo, 4);
VOP->brightness_change_factor = 625 + mp4_GetBits(pInfo, 10);
} else if (code == 14) {
mp4_FlushBits(pInfo, 4);
VOP->brightness_change_factor = 113 + mp4_GetBits9(pInfo, 9);
} else if (code >= 12) {
mp4_FlushBits(pInfo, 3);
code = mp4_GetBits9(pInfo, 7);
VOP->brightness_change_factor = (code < 64) ? code - 112 : code - 15;
} else if (code >= 8) {
mp4_FlushBits(pInfo, 2);
code = mp4_GetBits9(pInfo, 6);
VOP->brightness_change_factor = (code < 32) ? code - 48 : code - 15;
} else {
mp4_FlushBits(pInfo, 1);
code = mp4_GetBits9(pInfo, 5);
VOP->brightness_change_factor = (code < 16) ? code - 16 : code - 15;
}
} else
VOP->brightness_change_factor = 0;
if (VOL->sprite_enable == MP4_SPRITE_STATIC)
return MP4_STATUS_OK;
}
if (VOL->shape != MP4_SHAPE_TYPE_BINARYONLY) {
VOP->quant = mp4_GetBits9(pInfo, VOL->quant_precision);
if (VOL->shape == MP4_SHAPE_TYPE_GRAYSCALE) {
int32_t ac, i;
ac = mp4_aux_comp_count[VOL->shape_extension];
for (i = 0; i < ac; i ++)
VOP->alpha_quant[i] = mp4_GetBits9(pInfo, 6);
}
if (VOP->coding_type != MP4_VOP_TYPE_I) {
VOP->fcode_forward = mp4_GetBits9(pInfo, 3);
if (VOP->fcode_forward == 0) {
mp4_Error("Error: vop_fcode_forward == 0");
return MP4_STATUS_PARSE_ERROR;
}
}
if (VOP->coding_type == MP4_VOP_TYPE_B) {
VOP->fcode_backward = mp4_GetBits9(pInfo, 3);
if (VOP->fcode_backward == 0) {
mp4_Error("Error: vop_fcode_backward == 0");
return MP4_STATUS_PARSE_ERROR;
}
}
if (!VOL->scalability) {
if (VOL->shape != MP4_SHAPE_TYPE_RECTANGULAR && VOP->coding_type != MP4_VOP_TYPE_I)
VOP->shape_coding_type = mp4_GetBit(pInfo);
} else {
//f if (VOL->enhancement_type) {
//f VOP->load_backward_shape = mp4_GetBit(pInfo);
//f if (VOP->load_backward_shape) {
//f shape
//f }
//f }
VOP->ref_select_code = mp4_GetBits9(pInfo, 2);
}
}
return MP4_STATUS_OK;
}
/*
// decode VideoPacket
*/
mp4_Status mp4_CheckDecodeVideoPacket(mp4_Info* pInfo, int32_t *found)
{
uint32_t code;
int32_t header_extension_code, rml;
mp4_VideoObject *VOL = &pInfo->VisualObject.VideoObject;
mp4_VideoObjectPlane *VOP = &pInfo->VisualObject.VideoObject.VideoObjectPlane;
*found = 0;
// check stuffing bits
if (mp4_ShowBit(pInfo) != 0)
return MP4_STATUS_OK;
if (mp4_ShowBits9(pInfo, 8 - pInfo->bitoff) != (uint32_t)((1 << (7 - pInfo->bitoff)) - 1))
return MP4_STATUS_OK;
if (VOP->coding_type == MP4_VOP_TYPE_I)
rml = 17;
else if (VOP->coding_type == MP4_VOP_TYPE_B)
rml = 16 + IPP_MAX(VOP->fcode_forward, VOP->fcode_backward);
else
rml = 16 + VOP->fcode_forward;
code = (pInfo->bufptr[1] << 16) | (pInfo->bufptr[2] << 8) | pInfo->bufptr[3];
code >>= 24 - rml;
if (code == 1) { // is resync_marker
mp4_FlushBits(pInfo, rml + 8 - pInfo->bitoff);
header_extension_code = 0;
if (VOL->shape != MP4_SHAPE_TYPE_RECTANGULAR) {
header_extension_code = mp4_GetBit(pInfo);
if (header_extension_code && !(VOL->sprite_enable == MP4_SPRITE_STATIC && VOP->coding_type == MP4_VOP_TYPE_I)) {
VOP->vop_width = mp4_GetBits(pInfo, 13);
if (!mp4_GetBit(pInfo))
if (pInfo->stopOnErr)
goto Err;
VOP->vop_height = mp4_GetBits(pInfo, 13);
if (!mp4_GetBit(pInfo))
if (pInfo->stopOnErr)
goto Err;
VOP->vop_horizontal_mc_spatial_ref = mp4_GetBits(pInfo, 13);
if (!mp4_GetBit(pInfo))
if (pInfo->stopOnErr)
goto Err;
VOP->vop_vertical_mc_spatial_ref = mp4_GetBits(pInfo, 13);
if (!mp4_GetBit(pInfo))
if (pInfo->stopOnErr)
goto Err;
}
}
pInfo->VisualObject.VideoObject.VideoObjectPlane.macroblock_num = mp4_GetBits(pInfo, pInfo->VisualObject.VideoObject.mbns);
if (pInfo->VisualObject.VideoObject.VideoObjectPlane.macroblock_num >= pInfo->VisualObject.VideoObject.MacroBlockPerVOP)
goto Err;
if (VOL->shape != MP4_SHAPE_TYPE_BINARYONLY) {
pInfo->VisualObject.VideoObject.VideoObjectPlane.quant_scale = mp4_GetBits9(pInfo, VOL->quant_precision); // quant_scale
}
if (VOL->shape == MP4_SHAPE_TYPE_RECTANGULAR) {
header_extension_code = mp4_GetBit(pInfo);
}
if (header_extension_code) {
//f ignore modulo_time_base
do {
code = mp4_GetBit(pInfo);
} while (code);
if (!mp4_GetBit(pInfo))
if (pInfo->stopOnErr)
goto Err;
//f ignore vop_time_increment
if (VOL->vop_time_increment_resolution_bits != 0 ) {
code = mp4_GetBits(pInfo, VOL->vop_time_increment_resolution_bits);
}
if (!mp4_GetBit(pInfo))
if (pInfo->stopOnErr)
goto Err;
//f ignore vop_coding_type
code = mp4_GetBits9(pInfo, 2);
if (VOL->shape != MP4_SHAPE_TYPE_RECTANGULAR) {
VOP->change_conv_ratio_disable = mp4_GetBit(pInfo);
if (VOP->coding_type != MP4_VOP_TYPE_I)
VOP->shape_coding_type = mp4_GetBit(pInfo);
}
if (VOL->shape != MP4_SHAPE_TYPE_BINARYONLY) {
//f ignore intra_dc_vlc_thr
code = mp4_GetBits9(pInfo, 3);
if (VOL->sprite_enable == MP4_SPRITE_GMC && VOP->coding_type == MP4_VOP_TYPE_S && VOL->sprite_warping_points > 0)
if (mp4_Sprite_Trajectory(pInfo) != MP4_STATUS_OK)
if (pInfo->stopOnErr)
goto Err;
//f ignore vop_reduced_resolution
if (VOL->reduced_resolution_vop_enable && VOL->shape == MP4_SHAPE_TYPE_RECTANGULAR &&
(VOP->coding_type == MP4_VOP_TYPE_I || VOP->coding_type == MP4_VOP_TYPE_P))
code = mp4_GetBit(pInfo);
if (VOP->coding_type != MP4_VOP_TYPE_I)
VOP->fcode_forward = mp4_GetBits9(pInfo, 3);
if (VOP->coding_type == MP4_VOP_TYPE_B)
VOP->fcode_backward = mp4_GetBits9(pInfo, 3);
}
}
if (VOL->newpred_enable) {
int vop_id_length = VOL->vop_time_increment_resolution_bits + 3;
if (vop_id_length > 15)
vop_id_length = 15;
VOP->vop_id = mp4_GetBits(pInfo, vop_id_length);
VOP->vop_id_for_prediction_indication = mp4_GetBit(pInfo);
if (VOP->vop_id_for_prediction_indication)
VOP->vop_id_for_prediction = mp4_GetBits(pInfo, vop_id_length);
if (!mp4_GetMarkerBit(pInfo))
if (pInfo->stopOnErr)
goto Err;
}
*found = 1;
return MP4_STATUS_OK;
}
return MP4_STATUS_OK;
Err:
mp4_Error("Error: decoding Video Packet Header");
return MP4_STATUS_PARSE_ERROR;
}
int32_t mp4_CheckDecodeGOB_SVH(mp4_Info* pInfo)
{
int32_t code;
pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_number ++;
pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_header_empty = 1;
code = mp4_ShowBits(pInfo, 17); /* check gob_resync_marker */
if (code != 1) {
code = mp4_ShowBitsAlign(pInfo, 17); /* check next aligned bits are gob_resync_marker */
if (code == 1)
mp4_AlignBits(pInfo);
}
if (code == 1) {
mp4_FlushBits(pInfo, 17);
pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_header_empty = 0;
code = mp4_GetBits9(pInfo, 5); /* gob_number */
pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_frame_id = mp4_GetBits9(pInfo, 2);
pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.quant_scale = mp4_GetBits9(pInfo, 5);
// check gob_number is valid
//if (code > pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_number && code <= pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.num_gobs_in_vop)
if (code <= pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.num_gobs_in_vop)
pInfo->VisualObject.VideoObject.VideoObjectPlaneH263.gob_number = code;
else {
mp4_Error("Error: bad gob_number in GOB header");
return MP4_STATUS_ERROR;
}
}
return MP4_STATUS_OK;
}
Reference in a new issue View git blame Copy permalink