av_parsers.c

一个用于智能手机的多媒体库适合S60 WinCE的跨平台开发库

		case 12: return 320;
		case 13: return 384;
		default: return 0;
		}
		break;
	/* MPEG-1, Layer I */
	case 2:
		switch (idx2) {
		case 0: return 32;
		case 1: return 64;
		case 2: return 96;
		case 3: return 128;
		case 4: return 160;
		case 5: return 192;
		case 6: return 224;
		case 7: return 256;
		case 8: return 288;
		case 9: return 320;
		case 10: return 352;
		case 11: return 384;
		case 12: return 416;
		case 13: return 448;
		default: return 0;
		}
		break;
	/* MPEG-2 or 2.5, Layer II or III */
	case 3:
		switch (idx2) {
		case 0: return 8;
		case 1: return 16;
		case 2: return 24;
		case 3: return 32;
		case 4: return 40;
		case 5: return 48;
		case 6: return 56;
		case 7: return 64;
		case 8: return 80;
		case 9: return 96;
		case 10: return 112;
		case 11: return 128;
		case 12: return 144;
		case 13: return 160;
		default: return 0;
		}
		break;
	/* MPEG-2 or 2.5, Layer I */
	case 4:
		switch (idx2) {
		case 0: return 32;
		case 1: return 48;
		case 2: return 56;
		case 3: return 64;
		case 4: return 80;
		case 5: return 96;
		case 6: return 112;
		case 7: return 128;
		case 8: return 144;
		case 9: return 160;
		case 10: return 176;
		case 11: return 192;
		case 12: return 224;
		case 13: return 256;
		default: return 0;
		}
		break;
	default:
		return 0;
	}
}


GF_EXPORT
u16 gf_mp3_frame_size(u32 hdr)
{
	u32 val;
	u8 bitRateIndex1;
	u8 version = gf_mp3_version(hdr);
	u8 layer = MP3_GetLayerV(hdr);
	u8 bitRateIndex2 = (hdr >> 12) & 0xF;
	u8 sampleRateIndex = (hdr >> 10) & 0x3;
	Bool isPadded = (hdr >> 9) & 0x1;
	u32 frameSize = 0;

	if (version == 3) {
		bitRateIndex1 = layer - 1;
	} else {
		if (layer == 3) {
			bitRateIndex1 = 4;
		} else {
			bitRateIndex1 = 3;
		}
	}

	/* compute frame size */
	val = get_MP3SamplingRates(version, sampleRateIndex);
	if (!(version & 1)) val <<= 1;
	if (!val) return 0;
	frameSize = 144 * 1000 * get_MP3BitRates(bitRateIndex1, bitRateIndex2-1);
	frameSize /= val;

	if (isPadded) {
		if (layer == 3) {
			frameSize += 4;
		} else {
			frameSize++;
		}
	}
	return (u16) frameSize;
}


u16 gf_mp3_bit_rate(u32 hdr)
{
	u8 bitRateIndex1;
	u8 version = gf_mp3_version(hdr);
	u8 layer = MP3_GetLayerV(hdr);
	u8 bitRateIndex2 = (hdr >> 12) & 0xF;
	if (version == 3) {
		bitRateIndex1 = layer - 1;
	} else {
		if (layer == 3) {
			bitRateIndex1 = 4;
		} else {
			bitRateIndex1 = 3;
		}
	}

	/* compute frame size */
	return get_MP3BitRates(bitRateIndex1, bitRateIndex2-1);
}


GF_EXPORT
u32 gf_mp3_get_next_header(FILE* in)
{
	u8 b, state = 0;
	u32 dropped = 0;
	unsigned char bytes[4];
	bytes[0] = bytes[1] = bytes[2] = bytes[3] = 0;

	while (1) {
		if (fread(&b, 1, 1, in) == 0) return 0;

		if (state==3) {
			bytes[state] = b;
			return GF_4CC(bytes[0], bytes[1], bytes[2], bytes[3]);
		}
		if (state==2) {
			if (((b & 0xF0) == 0) || ((b & 0xF0) == 0xF0) || ((b & 0x0C) == 0x0C)) {
				if (bytes[1] == 0xFF) state = 1; 
				else state = 0; 
			} else {
				bytes[state] = b;
				state = 3;
			}
		}
		if (state==1) {
			if (((b & 0xE0) == 0xE0) && ((b & 0x18) != 0x08) && ((b & 0x06) != 0)) {
				bytes[state] = b;
				state = 2;
			} else {
				state = 0;
			}
		}

		if (state==0) {
			if (b == 0xFF) {
				bytes[state] = b;
				state = 1;
			} else {
				if ((dropped == 0) && ((b & 0xE0) == 0xE0) && ((b & 0x18) != 0x08) && ((b & 0x06) != 0)) {
					bytes[0] = (u8) 0xFF;
					bytes[1] = b;
					state = 2;
				} else {
					dropped++;
				}
			}
		}
	}
	return 0;
}

GF_EXPORT
u32 gf_mp3_get_next_header_mem(char *buffer, u32 size, u32 *pos)
{
	u32 cur;
	u8 b, state = 0;
	u32 dropped = 0;
	unsigned char bytes[4];
	bytes[0] = bytes[1] = bytes[2] = bytes[3] = 0;

	cur = 0;
	*pos = 0;
	while (cur<size) {
		b = (u8) buffer[cur];
		cur++;

		if (state==3) {
			u32 val;
			bytes[state] = b; 
			val = GF_4CC(bytes[0], bytes[1], bytes[2], bytes[3]);
			if (gf_mp3_frame_size(val)) {
				*pos = dropped;
				return val;
			}
			state = 0;
			dropped = cur;
		}
		if (state==2) {
			if (((b & 0xF0) == 0) || ((b & 0xF0) == 0xF0) || ((b & 0x0C) == 0x0C)) {
				if (bytes[1] == 0xFF) {
					state = 1; 
					dropped+=1;
				} else {
					state = 0;
					dropped = cur;
				}
			} else {
				bytes[state] = b;
				state = 3;
			}
		}
		if (state==1) {
			if (((b & 0xE0) == 0xE0) && ((b & 0x18) != 0x08) && ((b & 0x06) != 0)) {
				bytes[state] = b;
				state = 2;
			} else {
				state = 0;
				dropped = cur;
			}
		}

		if (state==0) {
			if (b == 0xFF) {
				bytes[state] = b;
				state = 1;
			} else {
				dropped++;
			}
		}
	}
	return 0;
}

#ifndef GPAC_READ_ONLY

/*
	MPEG-4 AVC/H264 parser

  Inspired from ffmpeg (LGPL) and MPEG4IP (MPL)

*/

static u8 avc_golomb_bits[256] = {
	8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 
	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
	1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
	0
};

static u32 avc_get_ue(GF_BitStream *bs)
{
	u8 coded;
	u32 bits, read;
	bits = 0;
	while (1) {
		read = gf_bs_peek_bits(bs, 8, 0);
		if (read) break;
		gf_bs_read_int(bs, 8);
		bits += 8;
	}
	coded = avc_golomb_bits[read];
	gf_bs_read_int(bs, coded);
	bits += coded;
	return gf_bs_read_int(bs, bits + 1) - 1;
}

static s32 avc_get_se(GF_BitStream *bs) 
{
	u32 v = avc_get_ue(bs);
	if ((v & 0x1) == 0) return (s32) (0 - (v>>1));
	return (v + 1) >> 1;
}

u32 AVC_IsStartCode(GF_BitStream *bs)
{
	u8 s1, s2, s3, s4;
	Bool is_sc = 0;
	u64 pos = gf_bs_get_position(bs);
	s1 = gf_bs_read_int(bs, 8);
	s2 = gf_bs_read_int(bs, 8);
	if (!s1 && !s2) {
		s3 = gf_bs_read_int(bs, 8);
		if (s3==0x01) is_sc = 3;
		else if (!s3) {
			s4 = gf_bs_read_int(bs, 8);
			if (s4==0x01) is_sc = 4;
		}
	}
	gf_bs_seek(bs, pos+is_sc);
	return is_sc;
}

/*read that amount of data at each IO access rather than fetching byte by byte...*/
#define AVC_CACHE_SIZE	4096
u32 AVC_NextStartCode(GF_BitStream *bs)
{
	u32 v, bpos;
	char avc_cache[AVC_CACHE_SIZE];
	u64 end, cache_start, load_size;
	u64 start = gf_bs_get_position(bs);
	if (start<3) return 0;
	
	load_size = 0;
	bpos = 0;
	cache_start = 0;
	end = 0;
	v = 0xffffffff;
	while (!end) {
		/*refill cache*/
		if (bpos == (u32) load_size) {
			if (!gf_bs_available(bs)) break;
			load_size = gf_bs_available(bs);
			if (load_size>AVC_CACHE_SIZE) load_size=AVC_CACHE_SIZE;
			bpos = 0;
			cache_start = gf_bs_get_position(bs);
			gf_bs_read_data(bs, avc_cache, (u32) load_size);
		}
		v = ( (v<<8) & 0xFFFFFF00) | ((u32) avc_cache[bpos]);
		bpos++;
		if (v == 0x00000001) end = cache_start+bpos-4;
		else if ( (v & 0x00FFFFFF) == 0x00000001) end = cache_start+bpos-3;
	}
	gf_bs_seek(bs, start);
	if (!end) end = gf_bs_get_size(bs);
	return (u32) (end-start);
}


Bool AVC_NALUIsSlice(u8 type)
{
	return ((type >= GF_AVC_NALU_NON_IDR_SLICE) && (type <= GF_AVC_NALU_IDR_SLICE)) ? 1 : 0;
}

Bool AVC_SliceIsIDR(AVCState *avc) 
{
  if (avc->sei.recovery_point.valid)
  {
	  avc->sei.recovery_point.valid = 0;
	  return 1;
  }
  if (avc->s_info.nal_unit_type != GF_AVC_NALU_IDR_SLICE) return 0;
  switch (avc->s_info.slice_type) {
  case GF_AVC_TYPE_I:
  case GF_AVC_TYPE2_I:
  case GF_AVC_TYPE_SI:
  case GF_AVC_TYPE2_SI:
	  return 1;
  default:
	  return 0;
  }
}

static const struct { u32 w, h; } avc_sar[14] =
{
    { 0,   0 }, { 1,   1 }, { 12, 11 }, { 10, 11 },
    { 16, 11 }, { 40, 33 }, { 24, 11 }, { 20, 11 },
    { 32, 11 }, { 80, 33 }, { 18, 11 }, { 15, 11 },
    { 64, 33 }, { 160,99 },
};

s32 AVC_ReadSeqInfo(GF_BitStream *bs, AVCState *avc, u32 *vui_flag_pos)
{
	AVC_SPS *sps;
	s32 mb_width, mb_height;
	u32 sps_id, profile_idc, level_idc, pcomp, i, chroma_format_idc, cl, cr, ct, cb;
	
	if (vui_flag_pos) *vui_flag_pos = 0;

	profile_idc = gf_bs_read_int(bs, 8);
	pcomp = gf_bs_read_int(bs, 8);
	level_idc = gf_bs_read_int(bs, 8);
    sps_id = avc_get_ue(bs);

	sps = &avc->sps[sps_id];
	if (!sps->status) sps->status = 1;

	/*High Profile cfg stuff*/	
	switch (profile_idc) {
	case 100:
	case 110:
	case 122:
	case 144:
		chroma_format_idc = avc_get_ue(bs);
		if (chroma_format_idc == 3) /*residual_colour_transform_flag = */ gf_bs_read_int(bs, 1);
		/*bit_depth_luma_minus8 = */ avc_get_ue(bs);
		/*bit_depth_chroma_minus8 = */ avc_get_ue(bs);
		/*qpprime_y_zero_transform_bypass_flag = */ gf_bs_read_int(bs, 1);
		/*seq_scaling_matrix_present_flag*/
		if (gf_bs_read_int(bs, 1)) {
			u32 k;
			for (k=0; k<8; k++) {
				if (gf_bs_read_int(bs, 1)) {
					u32 z, last = 8, next = 8;
					u32 sl = k<6 ? 16 : 64;
					for (z=0; z<sl; z++) {
						if (next) {
							s32 delta = avc_get_se(bs);
							next = (last + delta + 256) % 256;
						}
						last = next ? next : last;
					}
				}
			}
		}
		break;
	}	
	
	sps->profile_idc = profile_idc;
	sps->level_idc = level_idc;
	sps->prof_compat = pcomp;
    sps->log2_max_frame_num = avc_get_ue(bs) + 4;
    sps->poc_type = avc_get_ue(bs);

    if (sps->poc_type == 0) {
        sps->log2_max_poc_lsb = avc_get_ue(bs) + 4;
    } else if(sps->poc_type == 1) {
        sps->delta_pic_order_always_zero_flag = gf_bs_read_int(bs, 1);
        sps->offset_for_non_ref_pic = avc_get_se(bs);
        sps->offset_for_top_to_bottom_field = avc_get_se(bs);
        sps->poc_cycle_length = avc_get_ue(bs);
        for(i=0; i<sps->poc_cycle_length; i++) sps->offset_for_ref_frame[i] = avc_get_se(bs);
    }
    if (sps->poc_type > 2) return -1;
    avc_get_ue(bs); /*ref_frame_count*/
    gf_bs_read_int(bs, 1); /*gaps_in_frame_num_allowed_flag*/
    mb_width = avc_get_ue(bs) + 1;
    mb_height= avc_get_ue(bs) + 1;

    sps->frame_mbs_only_flag = gf_bs_read_int(bs, 1);

    sps->width = mb_width * 16;
    sps->height = (2-sps->frame_mbs_only_flag) * mb_height * 16;

	/*mb_adaptive_frame_field_flag*/
	if (!sps->frame_mbs_only_flag) gf_bs_read_int(bs, 1);
    gf_bs_read_int(bs, 1); /*direct_8x8_inference_flag*/
	cl = cr = ct = cb = 0;
    if (gf_bs_read_int(bs, 1)) /*crop*/ {
        cl = avc_get_ue(bs); /*crop_left*/
        cr = avc_get_ue(bs); /*crop_right*/
        ct = avc_get_ue(bs); /*crop_top*/
        cb = avc_get_ue(bs); /*crop_bottom*/

		sps->width = 16*mb_width - 2*(cl + cr);
		sps->height -= (2-sps->frame_mbs_only_flag)*2*(ct + cb);
    }

	if (vui_flag_pos) {
		*vui_flag_pos = (u32) gf_bs_get_bit_offset(bs);
	}

    /*vui_parameters_present_flag*/
    if (gf_bs_read_int(bs, 1)) {
		/*aspect_ratio_info_present_flag*/
		if (gf_bs_read_int(bs, 1)) {
			s32 aspect_ratio_idc = gf_bs_read_int(bs, 8);
			if (aspect_ratio_idc == 255) {
				sps->par_num = gf_bs_read_int(bs, 16); /*AR num*/
				sps->par_den = gf_bs_read_int(bs, 16); /*AR den*/
			} else if (aspect_ratio_idc<14) {
				sps->par_num = avc_sar[aspect_ratio_idc].w;
				sps->par_den = avc_sar[aspect_ratio_idc].h;
			}
		}
		if(gf_bs_read_int(bs, 1))       /* overscan_info_present_flag */
			gf_bs_read_int(bs, 1);      /* overscan_appropriate_flag */

		if (gf_bs_read_int(bs, 1)){      /* video_signal_type_present_flag */
			gf_bs_read_int(bs, 3);    /* video_format */
			gf_bs_read_int(bs, 1);      /* video_full_range_flag */
			if (gf_bs_read_int(bs, 1)){  /* colour_description_present_flag */
				gf_bs_read_int(bs, 8); /* colour_primaries */
				gf_bs_read_int(bs, 8); /* transfer_characteristics */
				gf_bs_read_int(bs, 8); /* matrix_coefficients */
			}
		}

		if (gf_bs_read_int(bs, 1)) {      /* chroma_location_info_present_flag */
			avc_get_ue(bs);  /* chroma_sample_location_type_top_field */