[AT&T Samsung Galaxy S II Skyrocket SGH-I727] wantowan2:
/*--------------------------------------------------------------------------

#include "mp4_utils.h"
#include "omx_vdec.h"
# include <stdio.h>
#ifdef _ANDROID_
extern "C"{
#include<utils/Log.h>
}
#endif//_ANDROID_

#undef DEBUG_PRINT_LOW
#undef DEBUG_PRINT_HIGH
#undef DEBUG_PRINT_ERROR

#define DEBUG_PRINT_LOW ALOGV
#define DEBUG_PRINT_HIGH ALOGV
#define DEBUG_PRINT_ERROR ALOGE

MP4_Utils::MP4_Utils()
{
m_SrcWidth = 0;
m_SrcHeight = 0;
vop_time_resolution = 0;
vop_time_found = false;

}
MP4_Utils::~MP4_Utils()
{
}

uint32 MP4_Utils::read_bit_field(posInfoType * posPtr, uint32 size) {
uint8 *bits = &posPtr->bytePtr[0];
uint32 bitBuf =
(bits[0] << 24) | (bits[1] << 16) | (bits[2] << 8) | bits[3];

uint32 value = (bitBuf >> (32 - posPtr->bitPos - size)) & MASK(size);

/* Update the offset in preparation for next field */
posPtr->bitPos += size;

while (posPtr->bitPos >= 8) {
posPtr->bitPos -= 8;
posPtr->bytePtr++;
}
return value;
}
static uint8 *find_code
(uint8 * bytePtr, uint32 size, uint32 codeMask, uint32 referenceCode) {
uint32 code = 0xFFFFFFFF;
for (uint32 i = 0; i < size; i++) {
code <<= 8;
code |= *bytePtr++;

if ((code & codeMask) == referenceCode) {
return bytePtr;
}
}

DEBUG_PRINT_LOW("Unable to find code 0x%x\n", referenceCode);
return NULL;
}
bool MP4_Utils::parseHeader(mp4StreamType * psBits) {
uint32 profile_and_level_indication = 0;
uint8 VerID = 1; /* default value */
long hxw = 0;

m_posInfo.bitPos = 0;
m_posInfo.bytePtr = psBits->data;
m_dataBeginPtr = psBits->data;

m_posInfo.bytePtr = find_code(m_posInfo.bytePtr,4,
MASK(32),VOP_START_CODE);
if(m_posInfo.bytePtr) {
return false;
}

m_posInfo.bitPos = 0;
m_posInfo.bytePtr = psBits->data;
m_dataBeginPtr = psBits->data;
m_posInfo.bytePtr = find_code(m_posInfo.bytePtr,4,
MASK(32),GOV_START_CODE);
if(m_posInfo.bytePtr) {
return false;
}

m_posInfo.bitPos = 0;
m_posInfo.bytePtr = psBits->data;
m_dataBeginPtr = psBits->data;
/* parsing Visual Object Seqence(VOS) header */
m_posInfo.bytePtr = find_code(m_posInfo.bytePtr,
psBits->numBytes,
MASK(32),
VISUAL_OBJECT_SEQUENCE_START_CODE);
if ( m_posInfo.bytePtr == NULL ){
m_posInfo.bitPos = 0;
m_posInfo.bytePtr = psBits->data;
}
else {
uint32 profile_and_level_indication = read_bit_field (&m_posInfo, 8);
}
/* parsing Visual Object(VO) header*/
/* note: for now, we skip over the user_data */
m_posInfo.bytePtr = find_code(m_posInfo.bytePtr,psBits->numBytes,
MASK(32),VISUAL_OBJECT_START_CODE);
if(m_posInfo.bytePtr == NULL) {
m_posInfo.bitPos = 0;
m_posInfo.bytePtr = psBits->data;
}
else {
uint32 is_visual_object_identifier = read_bit_field (&m_posInfo, 1);
if ( is_visual_object_identifier ) {
/* visual_object_verid*/
read_bit_field (&m_posInfo, 4);
/* visual_object_priority*/
read_bit_field (&m_posInfo, 3);
}

/* visual_object_type*/
uint32 visual_object_type = read_bit_field (&m_posInfo, 4);
if ( visual_object_type != VISUAL_OBJECT_TYPE_VIDEO_ID ) {
return false;
}
/* skipping video_signal_type params*/
/*parsing Video Object header*/
m_posInfo.bytePtr = find_code(m_posInfo.bytePtr,psBits->numBytes,
VIDEO_OBJECT_START_CODE_MASK,VIDEO_OBJECT_START_CODE);
if ( m_posInfo.bytePtr == NULL ) {
return false;
}
}

/* parsing Video Object Layer(VOL) header */
m_posInfo.bitPos = 0;
m_posInfo.bytePtr = find_code(m_posInfo.bytePtr,
psBits->numBytes,
VIDEO_OBJECT_LAYER_START_CODE_MASK,
VIDEO_OBJECT_LAYER_START_CODE);
if ( m_posInfo.bytePtr == NULL ) {
m_posInfo.bitPos = 0;
m_posInfo.bytePtr = psBits->data;
}

// 1 -> random accessible VOL
read_bit_field(&m_posInfo, 1);

uint32 video_object_type_indication = read_bit_field (&m_posInfo, 8);
if ( (video_object_type_indication != SIMPLE_OBJECT_TYPE) &&
(video_object_type_indication != SIMPLE_SCALABLE_OBJECT_TYPE) &&
(video_object_type_indication != CORE_OBJECT_TYPE) &&
(video_object_type_indication != ADVANCED_SIMPLE) &&
(video_object_type_indication != RESERVED_OBJECT_TYPE) &&
(video_object_type_indication != MAIN_OBJECT_TYPE)) {
return false;
}
/* is_object_layer_identifier*/
uint32 is_object_layer_identifier = read_bit_field (&m_posInfo, 1);
if (is_object_layer_identifier) {
uint32 video_object_layer_verid = read_bit_field (&m_posInfo, 4);
uint32 video_object_layer_priority = read_bit_field (&m_posInfo, 3);
VerID = (unsigned char)video_object_layer_verid;
}

/* aspect_ratio_info*/
uint32 aspect_ratio_info = read_bit_field (&m_posInfo, 4);
if ( aspect_ratio_info == EXTENDED_PAR ) {
/* par_width*/
read_bit_field (&m_posInfo, 8);
/* par_height*/
read_bit_field (&m_posInfo, 8);
}
/* vol_control_parameters */
uint32 vol_control_parameters = read_bit_field (&m_posInfo, 1);
if ( vol_control_parameters ) {
/* chroma_format*/
uint32 chroma_format = read_bit_field (&m_posInfo, 2);
if ( chroma_format != 1 ) {
return false;
}
/* low_delay*/
uint32 low_delay = read_bit_field (&m_posInfo, 1);
/* vbv_parameters (annex D)*/
uint32 vbv_parameters = read_bit_field (&m_posInfo, 1);
if ( vbv_parameters ) {
/* first_half_bitrate*/
uint32 first_half_bitrate = read_bit_field (&m_posInfo, 15);
uint32 marker_bit = read_bit_field (&m_posInfo, 1);
if ( marker_bit != 1) {
return false;
}
/* latter_half_bitrate*/
uint32 latter_half_bitrate = read_bit_field (&m_posInfo, 15);
marker_bit = read_bit_field (&m_posInfo, 1);
if ( marker_bit != 1) {
return false;
}
uint32 VBVPeakBitRate = (first_half_bitrate << 15) + latter_half_bitrate;
/* first_half_vbv_buffer_size*/
uint32 first_half_vbv_buffer_size = read_bit_field (&m_posInfo, 15);
marker_bit = read_bit_field (&m_posInfo, 1);
if ( marker_bit != 1) {
return false;
}
/* latter_half_vbv_buffer_size*/
uint32 latter_half_vbv_buffer_size = read_bit_field (&m_posInfo, 3);
uint32 VBVBufferSize = (first_half_vbv_buffer_size << 3) + latter_half_vbv_buffer_size;
/* first_half_vbv_occupancy*/
uint32 first_half_vbv_occupancy = read_bit_field (&m_posInfo, 11);
marker_bit = read_bit_field (&m_posInfo, 1);
if ( marker_bit != 1) {
return false;
}
/* latter_half_vbv_occupancy*/
uint32 latter_half_vbv_occupancy = read_bit_field (&m_posInfo, 15);
marker_bit = read_bit_field (&m_posInfo, 1);
if ( marker_bit != 1) {
return false;
}
}/* vbv_parameters*/
}/*vol_control_parameters*/

/* video_object_layer_shape*/
uint32 video_object_layer_shape = read_bit_field (&m_posInfo, 2);
uint8 VOLShape = (unsigned char)video_object_layer_shape;
if ( VOLShape != MPEG4_SHAPE_RECTANGULAR ) {
return false;
}
/* marker_bit*/
uint32 marker_bit = read_bit_field (&m_posInfo, 1);
if ( marker_bit != 1 ) {
return false;
}
/* vop_time_increment_resolution*/
uint32 vop_time_increment_resolution = read_bit_field (&m_posInfo, 16);
vop_time_resolution = vop_time_increment_resolution;
vop_time_found = true;
return true;
}

bool MP4_Utils::is_notcodec_vop(unsigned char *pbuffer, unsigned int len)
{
unsigned int index = 4,vop_bits=0;
unsigned int temp = vop_time_resolution - 1;
unsigned char vop_type=0,modulo_bit=0,not_coded=0;
if (!vop_time_found || !pbuffer || len < 5) {
return false;
}
if((pbuffer[0] == 0) && (pbuffer[1] == 0) && (pbuffer[2] == 1) && (pbuffer[3] == 0xB6)){
while(temp) {
vop_bits++;
temp >>= 1;
}
vop_type = (pbuffer[index] & 0xc0) >> 6;
unsigned bits_parsed = 2;
do {
modulo_bit = pbuffer[index] & (1 << (7-bits_parsed));
bits_parsed++;
index += bits_parsed/8;
bits_parsed = bits_parsed %8;
if(index >= len) {
return false;
}
}while(modulo_bit);
bits_parsed++; //skip marker bit
bits_parsed += vop_bits + 1;//Vop bit & Marker bits
index += bits_parsed/8;
if(index >= len) {
return false;
}
bits_parsed = bits_parsed % 8;
not_coded = pbuffer[index] & (1 << (7 - bits_parsed));
if(!not_coded){
return true;
}
}
return false;
}

This is that file.cpp you asked about.

Can you do that? Use a ****_common from a diff device? Or is that why they call it common? lol

And that link is for Qualcomm 7x30 media libraries

Thing I doin't get tho is that cm has it working fine aswell

Look at my local_manifest

This one ?

android_device_htc_msm8660-common