libeplayer3-arm: insert original blank lines from exteplayer3.git, for better merge

libeplayer3-arm/external/flv2mpeg4/src/bitreader.h

@@ -56,6 +56,7 @@ static uint32 get_u24(BR *p)
 	uint32 a = get_u8(p);
 	uint32 b = get_u8(p);
 	uint32 c = get_u8(p);
+
 	return (a << 16) | (b << 8) | c;
 }
 
@@ -65,6 +66,7 @@ static uint32 get_u32(BR *p)
 	uint32 b = get_u8(p);
 	uint32 c = get_u8(p);
 	uint32 d = get_u8(p);
+
 	return (a << 24) | (b << 16) | (c << 8) | d;
 }
 
@@ -82,10 +84,12 @@ static uint32 show_bits(BR *p, uint32 bits)
 {
 	const uint8 *pp;
 	uint32 tmp;
+
 	pp = p->buf + p->read;
 	tmp = (pp[0] << 24) | (pp[1] << 16) | (pp[2] << 8) | (pp[3]);
 	tmp <<= p->bitoffset;
 	tmp >>= 32 - bits;
+
 	return tmp;
 }
 
@@ -93,10 +97,12 @@ static int32 show_sbits(BR *p, uint32 bits)
 {
 	const uint8 *pp;
 	int32 tmp;
+
 	pp = p->buf + p->read;
 	tmp = (pp[0] << 24) | (pp[1] << 16) | (pp[2] << 8) | (pp[3]);
 	tmp <<= p->bitoffset;
 	tmp >>= 32 - bits;
+
 	return tmp;
 }
 
@@ -150,14 +156,17 @@ static int __inline get_vlc(BR *br, const VLCtab *table, int bits, int max_depth
 	index = show_bits(br, bits);
 	code  = table[index].code;
 	n     = table[index].n;
+
 	if (max_depth > 1 && n < 0)
 	{
 		flash_bits(br, bits);
 		nb_bits = -n;
+
 		index = show_bits(br, nb_bits) + code;
 		code = table[index].code;
 		n = table[index].n;
 	}
+
 	flash_bits(br, n);
 	return code;
 }

libeplayer3-arm/external/flv2mpeg4/src/bitwriter.h

@@ -57,12 +57,14 @@ static void __inline init_bw(BW *p, uint8 *buf, uint32 size)
 static void __inline forword_bits(BW *p, uint32 bits)
 {
 	p->bitoffset += bits;
+
 	if (p->bitoffset >= 32)
 	{
 		p->buf[p->pos++] = (p->tmp >> 24) & 0xff;
 		p->buf[p->pos++] = (p->tmp >> 16) & 0xff;
 		p->buf[p->pos++] = (p->tmp >> 8) & 0xff;
 		p->buf[p->pos++] = (p->tmp >> 0) & 0xff;
+
 		p->tmp = 0;
 		p->bitoffset -= 32;
 	}
@@ -71,6 +73,7 @@ static void __inline forword_bits(BW *p, uint32 bits)
 static void __inline put_bits(BW *p, uint32 bits, uint32 value)
 {
 	uint32 shift = 32 - p->bitoffset - bits;
+
 	if (shift <= 32)
 	{
 		p->tmp |= value << shift;
@@ -81,6 +84,7 @@ static void __inline put_bits(BW *p, uint32 bits, uint32 value)
 		shift = bits - (32 - p->bitoffset);
 		p->tmp |= value >> shift;
 		forword_bits(p, bits - shift);
+
 		p->tmp |= value << (32 - shift);
 		forword_bits(p, shift);
 	}
@@ -98,6 +102,7 @@ static void __inline pad_to_boundary(BW *p)
 static void __inline flash_bw(BW *p)
 {
 	pad_to_boundary(p);
+
 	switch (p->bitoffset)
 	{
 		case 0: // nothing to do
@@ -118,6 +123,7 @@ static void __inline flash_bw(BW *p)
 //		fprintf(stderr, "flash_bw error!(%d)\n", p->bitoffset);
 			break;
 	}
+
 	p->tmp = 0;
 	p->bitoffset = 0;
 }
@@ -136,6 +142,7 @@ static void __inline put_vlcdec(BW *bw, VLCDEC *vlcdec)
 static void __inline m4v_stuffing(BW *p)
 {
 	int length;
+
 	put_bits(p, 1, 0);
 	length = (- p->bitoffset) & 7;
 	if (length) put_bits(p, length, (1 << length) - 1);

libeplayer3-arm/external/flv2mpeg4/src/dcprediction.c

@@ -25,6 +25,7 @@
 
 #include "dcprediction.h"
 
+
 // M4V ADDED
 static const uint8 mpeg4_y_dc_scale_table[32] =
 {
@@ -43,10 +44,12 @@ static int __inline get_pred(int *dc_cur, int stride, int scale)
 {
 	/* B C
 	   A X */
+
 	int A = dc_cur[-1];
 	int B = dc_cur[-1 - stride];
 	int C = dc_cur[-stride];
 	int pred;
+
 	if (abs(A - B) < abs(B - C))
 	{
 		pred = C;
@@ -55,6 +58,7 @@ static int __inline get_pred(int *dc_cur, int stride, int scale)
 	{
 		pred = A;
 	}
+
 	return (pred + (scale >> 1)) / scale;
 }
 
@@ -68,6 +72,7 @@ static void __inline set_dc_to_dc_cur(int *dc_cur, int level, int scale)
 		else
 			level = 2047;
 	}
+
 	dc_cur[0] = level;
 }
 
@@ -118,6 +123,7 @@ int dcpred_for_enc(M4V_DCPRED *p, int n, int level)
 	int *dc_cur = p->dc_cur[n];
 	int scale = get_scale(p, n);
 	int pred = get_pred(dc_cur, p->stride[n], scale);
+
 	set_dc_to_dc_cur(dc_cur, level, scale);
 	return level - pred;
 }
@@ -127,6 +133,7 @@ int dcpred_for_dec(M4V_DCPRED *p, int n, int level)
 	int *dc_cur = p->dc_cur[n];
 	int scale = get_scale(p, n);
 	int pred = get_pred(dc_cur, p->stride[n], scale);
+
 	level += pred;
 	set_dc_to_dc_cur(dc_cur, level, scale);
 	return level;
@@ -137,6 +144,7 @@ static void init_plane(M4V_DCPRED *pred, int n)
 {
 	int x, len = pred->stride[n] * pred->height[n];
 	int *p = pred->_dc[n];
+
 	for (x = 0; x < len; x++)
 	{
 		p[x] = 1024;
@@ -156,16 +164,20 @@ void alloc_dcpred(M4V_DCPRED *pred, int mb_width, int mb_height)
 	const int h2 = mb_height * 2 + 1;
 	const int w = mb_width      + 1;
 	const int h = mb_height     + 1;
+
 	pred->_dc[0] = pred->_dc[1] = pred->_dc[2] = pred->_dc[3] = (int *)malloc(sizeof(int) * w2 * h2);
 	pred->_dc[4] = (int *)malloc(sizeof(int) * w * h);
 	pred->_dc[5] = (int *)malloc(sizeof(int) * w * h);
+
 	pred->dc[0] = pred->dc[1] = pred->dc[2] = pred->dc[3] = pred->_dc[0] + w2 + 1;
 	pred->dc[4] = pred->_dc[4] + w + 1;
 	pred->dc[5] = pred->_dc[5] + w + 1;
+
 	pred->stride[0] = pred->stride[1] = pred->stride[2] = pred->stride[3] = w2;
 	pred->height[0] = pred->height[1] = pred->height[2] = pred->height[3] = h2;
 	pred->stride[4] = pred->stride[5] = w;
 	pred->height[4] = pred->height[5] = h;
+
 	pred->block_offset[0] = 0;
 	pred->block_offset[1] = 1;
 	pred->block_offset[2] = w2;

libeplayer3-arm/external/flv2mpeg4/src/dcprediction.h

@@ -40,6 +40,7 @@ typedef struct _M4V_DCPRED
 	int y_dc_scale;
 	int c_dc_scale;
 
+
 } M4V_DCPRED;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

libeplayer3-arm/external/flv2mpeg4/src/flv.h

@@ -65,6 +65,7 @@ typedef struct _PICTURE
 	int width;
 	int height;
 
+
 #define FLV_I_TYPE      0
 #define FLV_P_TYPE      1
 
@@ -156,4 +157,5 @@ static const int8 rl_inter_run[102] =
 static const int rl_inter_n = 102;
 static const int rl_inter_last = 58;
 
+
 #endif // FLV_H

libeplayer3-arm/external/flv2mpeg4/src/flv2mpeg4.c

@@ -41,6 +41,7 @@ typedef struct _CONVCTX
 	M4V_VOL vol;
 } CONVCTX;
 
+
 typedef struct
 {
 	uint8   *out_buf;
@@ -64,6 +65,7 @@ static const uint8 ff_mpeg4_c_dc_scale_table[32] =
 	0, 8, 8, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 20, 21, 22, 23, 24, 25
 };
 
+
 static void copy_vol(PICTURE *flv_pic, M4V_VOL *vol)
 {
 	vol->width = flv_pic->width;
@@ -74,9 +76,11 @@ static void copy_vol(PICTURE *flv_pic, M4V_VOL *vol)
 static void copy_vop(PICTURE *flv_pic, M4V_VOP *vop, CONVCTX *c)
 {
 	vop->qscale = flv_pic->qscale;
+
 	vop->time = c->frame % 30;
 	vop->icount = (c->icounter + 29) / 30;
 	vop->intra_dc_threshold = 99;
+
 	if (flv_pic->picture_type == FLV_I_TYPE)
 	{
 		vop->picture_type = M4V_I_TYPE;
@@ -91,13 +95,16 @@ static void copy_vop(PICTURE *flv_pic, M4V_VOP *vop, CONVCTX *c)
 static void copy_microblock(MICROBLOCK *flv_mb, M4V_MICROBLOCK *m4v_mb)
 {
 	int i;
+
 	m4v_mb->dquant = flv_mb->dquant;
 	memcpy(m4v_mb->block, flv_mb->block, sizeof(m4v_mb->block)); // !!!!!!!
 	m4v_mb->intra = flv_mb->intra;
 	m4v_mb->skip = flv_mb->skip;
 	m4v_mb->mv_type = flv_mb->mv_type;
+
 	memcpy(m4v_mb->mv_x, flv_mb->mv_x, sizeof(m4v_mb->mv_x)); // !!!!!!
 	memcpy(m4v_mb->mv_y, flv_mb->mv_y, sizeof(m4v_mb->mv_y)); // !!!!!!
+
 	// dc rescale
 	if (m4v_mb->intra)
 	{
@@ -106,6 +113,7 @@ static void copy_microblock(MICROBLOCK *flv_mb, M4V_MICROBLOCK *m4v_mb)
 			m4v_mb->block[i].block[0] *= 8;
 			m4v_mb->block[i].block[0] /= ff_mpeg4_y_dc_scale_table[m4v_mb->qscale];
 		}
+
 		for (i = 4; i < 6; i++)
 		{
 			m4v_mb->block[i].block[0] *= 8;
@@ -126,7 +134,9 @@ static int write_pad_not_coded_frames(flv2mpeg4_CTX *pub_ctx, CONVCTX *c, BW *bw
 		vop.icount = (c->icounter + 29) / 30;
 		m4v_encode_vop_header(bw, &vop, VOL_TIME_BITS, 1);
 		m4v_stuffing(bw);
+
 		flash_bw(bw);
+
 		// write frame
 		if (pub_ctx->write_packet_cb(pub_ctx->usr_data,
 		                             0,
@@ -136,10 +146,13 @@ static int write_pad_not_coded_frames(flv2mpeg4_CTX *pub_ctx, CONVCTX *c, BW *bw
 		{
 			return -1;
 		}
+
 		clear_bw(bw);
+
 		c->frame++;
 		c->icounter++;
 	}
+
 	return 0;
 }
 
@@ -151,9 +164,12 @@ static int write_m4v_picture_frame(flv2mpeg4_CTX *pub_ctx, CONVCTX *c, BR *br, B
 	int x, y;
 	int mb_width = (flvpic->width + 15) / 16;
 	int mb_height = (flvpic->height + 15) / 16;
+
 	memset(&vop, 0, sizeof(vop));
+
 	copy_vop(flvpic, &vop, c);
 	m4v_encode_vop_header(bw, &vop, VOL_TIME_BITS, 0);
+
 	// transcode flv to mpeg4
 	for (y = 0; y < mb_height; y++)
 	{
@@ -161,6 +177,7 @@ static int write_m4v_picture_frame(flv2mpeg4_CTX *pub_ctx, CONVCTX *c, BR *br, B
 		{
 			memset(&mb, 0, sizeof(mb));
 			memset(&m4v_mb, 0, sizeof(m4v_mb));
+
 			if (vop.picture_type == M4V_I_TYPE)
 			{
 				mb.intra = 1;
@@ -180,8 +197,10 @@ static int write_m4v_picture_frame(flv2mpeg4_CTX *pub_ctx, CONVCTX *c, BR *br, B
 			}
 		}
 	}
+
 	m4v_stuffing(bw);
 	flash_bw(bw);
+
 	// write frame
 	if (pub_ctx->write_packet_cb(pub_ctx->usr_data,
 	                             vop.picture_type == M4V_I_TYPE,
@@ -191,19 +210,25 @@ static int write_m4v_picture_frame(flv2mpeg4_CTX *pub_ctx, CONVCTX *c, BR *br, B
 	{
 		return -1;
 	}
+
 	c->frame++;
 	c->icounter++;
+
 	return 0;
 }
 
 static int write_m4v_frame(flv2mpeg4_CTX *pub_ctx, CONVCTX *c, BR *br, BW *bw, uint32 time)
 {
 	PICTURE picture;
+
 	memset(&picture, 0, sizeof(picture));
 	init_dcpred(&c->vol.dcpred);
+
 	if (decode_picture_header(br, &picture) < 0) return -1;
 	if (c->width != picture.width || c->height != picture.height) return -1; //size changed..
+
 	copy_vol(&picture, &c->vol);
+
 	if (picture.picture_type == FLV_I_TYPE)
 	{
 		c->icounter = 0;
@@ -212,10 +237,12 @@ static int write_m4v_frame(flv2mpeg4_CTX *pub_ctx, CONVCTX *c, BR *br, BW *bw, u
 	{
 		if (write_pad_not_coded_frames(pub_ctx, c, bw, time) < 0) return -1;
 	}
+
 	if (write_m4v_picture_frame(pub_ctx, c, br, bw, &picture, time) < 0)
 	{
 		return -1;
 	}
+
 	return 0;
 }
 
@@ -235,16 +262,23 @@ int flv2mpeg4_prepare_extra_data(flv2mpeg4_CTX *ctx)
 	CTX *p = ctx->priv;
 	BW bw;
 	CONVCTX *c = &(p->conv);
+
 	M4V_VOP vop;
 	memset(&vop, 0, sizeof(vop));
+
 	init_bw(&bw, p->out_buf, PACKETBUFFER_SIZE);
+
 	c->vol.width = c->width;
 	c->vol.height = c->height;
 	c->vol.time_bits = VOL_TIME_BITS; // 0-31
+
 	m4v_encode_m4v_header(&bw, &c->vol, 0);
+
 	m4v_stuffing(&bw);
 	flash_bw(&bw);
+
 	alloc_dcpred(&c->vol.dcpred, (c->width + 15) / 16, (c->height + 15) / 16);
+
 	return ctx->write_extradata_cb(ctx->usr_data, c->width, c->height, 200 * 1000, bw.buf, bw.pos);
 }
 
@@ -265,20 +299,26 @@ flv2mpeg4_CTX *flv2mpeg4_init_ctx(void *priv_data, int width, int height, flv2mp
 	pub_ctx->priv = malloc(sizeof(CTX));
 	memset(pub_ctx->priv, 0x0, sizeof(CTX));
 	CTX *ctx = pub_ctx->priv;
+
 	ctx->conv.width  = width;
 	ctx->conv.height = height;
 	ctx->out_buf = malloc(PACKETBUFFER_SIZE);
 	memset(ctx->out_buf, 0x0, PACKETBUFFER_SIZE);
 	memset(&(ctx->vol), 0x0, sizeof(ctx->vol));
+
 	return pub_ctx;
 }
 
 void flv2mpeg4_release_ctx(flv2mpeg4_CTX **pub_ctx)
 {
 	CTX *ctx = (*pub_ctx)->priv;
+
 	free_dcpred(&ctx->conv.vol.dcpred);
 	free(ctx->out_buf);
 	free(ctx);
 	free(*pub_ctx);
 	*pub_ctx = NULL;
 }
+
+
+

libeplayer3-arm/external/flv2mpeg4/src/flvdecoder.c

@@ -38,6 +38,7 @@ static const uint8 zig_zag_scan[64] =
 	58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
 };
 
+
 static const VLCtab vlc_table_intra_MCBPC[] = //: table_size=72 table_allocated=128 bits=6
 {
 	{64, -3},
@@ -127,6 +128,7 @@ static const VLCtab vlc_table_rl_inter[] = //: table_size=554 table_allocated=10
 	{100, 3}, {101, 3}, {8, 1}, {7, 1}
 };
 
+
 static const VLCtab vlc_table_mv[] = //mv_vlc: table_size=538 table_allocated=1024 bits=9
 {
 	{512, -3}, {520, -2}, {524, -1}, {526, -1}, {528, -1}, {530, -1}, {532, -1}, {534, -1}, {536, -1}, {10, 9},
@@ -181,6 +183,7 @@ static int __inline decode_DC(BR *p)
 		return -1;
 	}
 	if (level == 255) level = 128;
+
 //	printf("DC: %d\n", level);
 	return level;
 }
@@ -188,6 +191,7 @@ static int __inline decode_DC(BR *p)
 static int __inline decode_AC(BR *p, BLOCK *block, int escape_type, int i)
 {
 	int code, run, level, last, sign;
+
 	while (1)
 	{
 		code = get_vlc(p, vlc_table_rl_inter, 9, 2);
@@ -196,12 +200,14 @@ static int __inline decode_AC(BR *p, BLOCK *block, int escape_type, int i)
 			printf("invalid Huffman code in getblock()\n");
 			return -1;
 		}
+
 		if (code == rl_inter_n)
 		{
 			//escape
 			if (escape_type == 1)
 			{
 				int is11bit = get_bits(p, 1);
+
 				last = get_bits(p, 1);
 				run = get_bits(p, 6);
 				if (is11bit)
@@ -227,9 +233,11 @@ static int __inline decode_AC(BR *p, BLOCK *block, int escape_type, int i)
 			run = rl_inter_run[code];
 			level = rl_inter_level[code];
 			last = code >= rl_inter_last;
+
 			sign = get_bits(p, 1);
 			if (sign) level = -level;
 		}
+
 		i += run;
 		if (i >= 64)
 		{
@@ -240,6 +248,7 @@ static int __inline decode_AC(BR *p, BLOCK *block, int escape_type, int i)
 		if (last) break;
 		i++;
 	}
+
 	block->last_index = i;
 	return 0;
 }
@@ -252,12 +261,15 @@ static int __inline decode_intra_block(BR *p, BLOCK *block, int escape_type, int
 		printf("dc error.\n");
 		return -1;
 	}
+
 	block->block[0] = level;
 	block->last_index = 0;
+
 	if (!coded)
 	{
 		return 0;
 	}
+
 	if (decode_AC(p, block, escape_type, 1) < 0) return -1;
 	return 0;
 }
@@ -265,10 +277,12 @@ static int __inline decode_intra_block(BR *p, BLOCK *block, int escape_type, int
 static int __inline decode_inter_block(BR *p, BLOCK *block, int escape_type, int coded)
 {
 	block->last_index = -1;
+
 	if (!coded)
 	{
 		return 0;
 	}
+
 	if (decode_AC(p, block, escape_type, 0) < 0) return -1;
 	return 0;
 }
@@ -298,6 +312,7 @@ static int __inline get_inter_MCBPC(BR *br)
 		if (cbpc < 0) return -1;
 	}
 	while (cbpc == 20);
+
 	return cbpc;
 }
 
@@ -316,11 +331,14 @@ static int __inline decode_motion(BR *br, VLCDEC *vlcdec)
 {
 	int tmp;
 	int code = get_vlcdec(br, vlc_table_mv, 9, 2, vlcdec);
+
 	vlcdec->bits_ex = 0;
+
 	if (code == 0)
 		return 0;
 	if (code < 0)
 		return -1;
+
 	tmp = get_bits(br, 1);
 	/*
 	    vlcdec->value |= (tmp << vlcdec->bits);
@@ -331,6 +349,7 @@ static int __inline decode_motion(BR *br, VLCDEC *vlcdec)
 	*/
 	vlcdec->bits_ex = 1;
 	vlcdec->value_ex = tmp;
+
 	return 0;
 }
 
@@ -338,23 +357,28 @@ static int __inline decode_intra_mb_internal(BR *p, MICROBLOCK *mb, int escape_t
 {
 	int cbpy, cbp;
 	int i;
+
 	cbpy = get_cbpy(p);
 	if (cbpy < 0)
 	{
 		printf("cbpy error\n");
 		return -1;
 	}
+
 	cbp = (cbpc & 3) | (cbpy << 2);
+
 	if (dquant)
 	{
 		mb->dquant = decode_dquant(p);
 		qscale += mb->dquant;
 	}
+
 	for (i = 0; i < 6; i++)
 	{
 		if (decode_intra_block(p, &mb->block[i], escape_type, cbp & 32) != 0) return -1;
 		cbp += cbp;
 	}
+
 	return 0;
 }
 
@@ -362,19 +386,23 @@ static int __inline decode_inter_mb_internal(BR *p, MICROBLOCK *mb, int escape_t
 {
 	int cbpy, cbp;
 	int i;
+
 	cbpy = get_cbpy(p);
 	if (cbpy < 0)
 	{
 		printf("cbpy error\n");
 		return -1;
 	}
+
 	cbpy ^= 0xF;
 	cbp = (cbpc & 3) | (cbpy << 2);
+
 	if (dquant)
 	{
 		mb->dquant = decode_dquant(p);
 		qscale += mb->dquant;
 	}
+
 	if ((cbpc & 16) == 0)
 	{
 		// 16x16 motion prediction
@@ -392,11 +420,13 @@ static int __inline decode_inter_mb_internal(BR *p, MICROBLOCK *mb, int escape_t
 		}
 		mb->mv_type = MV_TYPE_8X8;
 	}
+
 	for (i = 0; i < 6; i++)
 	{
 		if (decode_inter_block(p, &mb->block[i], escape_type, cbp & 32) != 0) return -1;
 		cbp += cbp;
 	}
+
 	return 0;
 }
 
@@ -410,18 +440,22 @@ int decode_I_mb(BR *p, MICROBLOCK *mb, int escape_type, int qscale)
 		printf("intra_MCBPC error\n");
 		return -1;
 	}
+
 	dquant = cbpc & 4;
 	decode_intra_mb_internal(p, mb, escape_type, qscale, cbpc, dquant);
+
 	if (show_bits(p, 16) == 0)
 	{
 //		printf("slice end???\n");
 	}
+
 	return 0;
 }
 
 int decode_P_mb(BR *p, MICROBLOCK *mb, int escape_type, int qscale)
 {
 	int cbpc = get_inter_MCBPC(p);
+
 	if (cbpc == -1)
 	{
 		printf("inter_MCBPC error\n");
@@ -435,6 +469,7 @@ int decode_P_mb(BR *p, MICROBLOCK *mb, int escape_type, int qscale)
 	{
 		int dquant = cbpc & 8;
 		mb->skip = 0;
+
 		if ((cbpc & 4) != 0)
 		{
 			mb->intra = 1;
@@ -446,31 +481,38 @@ int decode_P_mb(BR *p, MICROBLOCK *mb, int escape_type, int qscale)
 			decode_inter_mb_internal(p, mb, escape_type, qscale, cbpc, dquant);
 		}
 	}
+
 	if (show_bits(p, 16) == 0)
 	{
 //		printf("slice end???\n");
 	}
+
 	return 0;
 }
 
 int decode_picture_header(BR *p, PICTURE *picture)
 {
 	int tmp, width = 0, height = 0;
+
 	if (get_bits(p, 17) != 1)
 	{
 		fprintf(stderr, "start code error\n");
 		return -1;
 	}
+
 	tmp = get_bits(p, 5);
 	if (tmp != 0 && tmp != 1)
 	{
 		fprintf(stderr, "picture format error\n");
 		return -1;
 	}
+
 	picture->escape_type = tmp;
 	picture->frame_number = get_bits(p, 8);
+
 //	printf("picture_format: %d\n", tmp);
 //	printf("picture_number: %d\n", get_bits(p, 8));
+
 	tmp = get_bits(p, 3);
 	switch (tmp)
 	{
@@ -501,21 +543,27 @@ int decode_picture_header(BR *p, PICTURE *picture)
 			fprintf(stderr, "size error\n");
 			return -1;
 	}
+
 	picture->width = width;
 	picture->height = height;
 //	printf("width: %d height: %d\n", width, height);
+
 	picture->picture_type = get_bits(p, 2);
 //	printf("picture_type: %d\n", tmp);
+
 	tmp = get_bits(p, 1);
 //	printf("deblocking flag: %d\n", tmp);
+
 	tmp = get_bits(p, 5);
 	picture->qscale = tmp;
 //	printf("qscale: %d\n", tmp);
+
 	// PEI
 	while (get_bits(p, 1) != 0)
 	{
 		flash_bits(p, 8);
 	}
+
 //	dump_marker(0, "dd header end");
 	return 0;
 }

libeplayer3-arm/external/flv2mpeg4/src/m4v.h

@@ -134,4 +134,6 @@ static const uint8 alternate_vertical_scan[64] =
 	38, 46, 54, 62, 39, 47, 55, 63,
 };
 
+
 #endif // M4V_H
+

libeplayer3-arm/external/flv2mpeg4/src/m4vencode.c

@@ -63,6 +63,7 @@ static const uint32 vlce_inter_MCBPC_bits[28] =
 static void __inline encode_DC(BW *p, int level, int n)
 {
 	if (level < -255 || level > 255) printf("dc overflow\n");
+
 #if 1
 	level += 256;
 	if (n < 4)
@@ -74,6 +75,7 @@ static void __inline encode_DC(BW *p, int level, int n)
 		put_bits(p, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
 	}
 #else
+
 	int size, v;
 	/* find number of bits */
 	size = 0;
@@ -83,6 +85,7 @@ static void __inline encode_DC(BW *p, int level, int n)
 		v >>= 1;
 		size++;
 	}
+
 	if (n < 4)
 	{
 		/* luminance */
@@ -93,6 +96,7 @@ static void __inline encode_DC(BW *p, int level, int n)
 		/* chrominance */
 		put_bits(p, DCtab_chrom[size][1], DCtab_chrom[size][0]);
 	}
+
 	/* encode remaining bits */
 	if (size > 0)
 	{
@@ -102,7 +106,9 @@ static void __inline encode_DC(BW *p, int level, int n)
 		if (size > 8)
 			put_bits(p, 1, 1);
 	}
+
 #endif
+
 }
 
 static void __inline encode_escape_3(BW *p, int last, int run, int level)
@@ -129,10 +135,13 @@ static void __inline encode_AC(BW *p, M4V_BLOCK *block, int intra)
 	int i = intra;
 	int last_index = block->last_index;
 	int last_non_zero = i - 1;
+
 	const uint8  *scan_table = zig_zag_scan; // !!!
+
 #if 1
 	const uint8  *len_tab;
 	const uint32 *bits_tab;
+
 	if (intra)
 	{
 		len_tab  = uni_mpeg4_intra_rl_len;
@@ -143,6 +152,7 @@ static void __inline encode_AC(BW *p, M4V_BLOCK *block, int intra)
 		len_tab  = uni_mpeg4_inter_rl_len;
 		bits_tab = uni_mpeg4_inter_rl_bits;
 	}
+
 	for (; i < last_index; i++)
 	{
 		int level = block->block[scan_table[i]];
@@ -159,9 +169,11 @@ static void __inline encode_AC(BW *p, M4V_BLOCK *block, int intra)
 			{
 				encode_escape_3(p, 0, run, level);
 			}
+
 			last_non_zero = i;
 		}
 	}
+
 	{
 		int level = block->block[scan_table[i]];
 		int run = i - last_non_zero - 1;
@@ -179,6 +191,7 @@ static void __inline encode_AC(BW *p, M4V_BLOCK *block, int intra)
 #else
 	const RL *rl;
 	int last, sign, code;
+
 	if (intra)
 	{
 		rl = &rl_intra;
@@ -187,6 +200,7 @@ static void __inline encode_AC(BW *p, M4V_BLOCK *block, int intra)
 	{
 		rl = &rl_inter;
 	}
+
 	for (; i <= last_index; i++)
 	{
 		const int slevel = block->block[scan_table[i]];
@@ -202,6 +216,7 @@ static void __inline encode_AC(BW *p, M4V_BLOCK *block, int intra)
 				sign = 1;
 				level = -level;
 			}
+
 			code = get_rl_index(rl, last, run, level);
 			put_bits(p, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 			if (code == rl->n)
@@ -210,6 +225,7 @@ static void __inline encode_AC(BW *p, M4V_BLOCK *block, int intra)
 				level1 = level - rl->max_level[run][last];
 				if (level1 < 1)
 					goto esc2;
+
 				code = get_rl_index(rl, last, run, level1);
 				if (code == rl->n)
 				{
@@ -255,7 +271,10 @@ esc3:
 			last_non_zero = i;
 		}
 	}
+
 #endif
+
+
 }
 
 static void __inline encode_intra_block(BW *bw, M4V_BLOCK *block, int n)
@@ -293,6 +312,7 @@ static void __inline encode_inter_8x8_MCBPC(BW *bw, int cbpc)
 	put_bits(bw, vlce_inter_MCBPC_bits[cbpc + 16], vlce_inter_MCBPC_code[cbpc + 16]);
 }
 
+
 // same as H.263
 static void __inline encode_cbpy(BW *bw, int cbpy)
 {
@@ -320,6 +340,7 @@ static void __inline encode_motion(BW *bw, VLCDEC *mv_x, VLCDEC *mv_y)
 		{
 			put_bits(bw, mv_x->bits_ex - 1, mv_x->value_ex >> 1);
 		}
+
 	}
 	put_vlcdec(bw, mv_y);
 	if (mv_y->bits_ex)
@@ -337,6 +358,7 @@ static void __inline encode_mb_inter_internal(BW *bw, M4V_MICROBLOCK *mb)
 {
 	int cbp = 0, cbpc, cbpy;
 	int i;
+
 	for (i = 0; i < 6; i++)
 	{
 		if (mb->block[i].last_index >= 0)
@@ -344,10 +366,13 @@ static void __inline encode_mb_inter_internal(BW *bw, M4V_MICROBLOCK *mb)
 			cbp |= 1 << (5 - i);
 		}
 	}
+
 	cbpc = cbp & 3;
 	cbpy = cbp >> 2;
 	cbpy ^= 0xF;
+
 	if (mb->dquant) cbpc += 8;
+
 	switch (mb->mv_type)
 	{
 		case MV_TYPE_16X16:
@@ -366,6 +391,7 @@ static void __inline encode_mb_inter_internal(BW *bw, M4V_MICROBLOCK *mb)
 			}
 			break;
 	}
+
 	for (i = 0; i < 6; i++)
 	{
 		encode_inter_block(bw, &mb->block[i]);
@@ -376,6 +402,7 @@ static void __inline encode_mb_intra_internal(BW *bw, M4V_MICROBLOCK *mb, int if
 {
 	int cbp = 0, cbpc, cbpy;
 	int i;
+
 	for (i = 0; i < 6; i++)
 	{
 		if (mb->block[i].last_index >= 1)
@@ -383,6 +410,7 @@ static void __inline encode_mb_intra_internal(BW *bw, M4V_MICROBLOCK *mb, int if
 			cbp |= 1 << (5 - i);
 		}
 	}
+
 	cbpc = cbp & 3;
 	if (iframe)
 	{
@@ -394,10 +422,15 @@ static void __inline encode_mb_intra_internal(BW *bw, M4V_MICROBLOCK *mb, int if
 		if (mb->dquant) cbpc += 8;
 		encode_intra_P_MCBPC(bw, cbpc);
 	}
+
 	put_bits(bw, 1, 0); // AC Prediction = no
+
 	cbpy = cbp >> 2;
+
 	encode_cbpy(bw, cbpy);
 	encode_dquant(bw, mb->dquant);
+
+
 	for (i = 0; i < 6; i++)
 	{
 		encode_intra_block(bw, &mb->block[i], i);
@@ -409,15 +442,20 @@ static int __inline encode_vo_header(BW *p)
 {
 	put_bits(p, 16, 0);
 	put_bits(p, 16, VOS_STARTCODE);
+
 	put_bits(p, 8, 1); // *** profile_and_level_indidation
+
 	put_bits(p, 16, 0);
 	put_bits(p, 16, VISUAL_OBJECT_STARTCODE);
+
 	put_bits(p, 1, 1);
 	put_bits(p, 4, 1); // vo_vel_id
 	put_bits(p, 3, 1); // priority
 	put_bits(p, 4, 1); // visual_object_type = video object
 	put_bits(p, 1, 0); // video signal type = no clue
+
 	m4v_stuffing(p);
+
 	return 0;
 }
 
@@ -425,19 +463,28 @@ static int __inline encode_vol_header(BW *p, M4V_VOL *vol)
 {
 	const int vo_number = 0;
 	const int vol_number = 0;
+
 	put_bits(p, 16, 0);
 	put_bits(p, 16, 0x100 + vo_number);
+
 	put_bits(p, 16, 0);
 	put_bits(p, 16, 0x120 + vol_number);
+
 	put_bits(p, 1, 0); // random_accessible_vol
 	put_bits(p, 8, 1); // video_object_type_indication = Simple Object Type
+
 	put_bits(p, 1, 0); //is_object_layer_identifier
+
 	put_bits(p, 4, 1); // *** aspect_ratio_info = 1(1:1)
+
 	put_bits(p, 1, 0); //vol_control_parameters
+
 	put_bits(p, 2, 0); // shape_type
 	put_bits(p, 1, 1); // marker
+
 	if (vol->time_bits != 5) return -1; // for vop_time_increment_resolution = 30
 	put_bits(p, 16, 30); // *** vop_time_increment_resolution = 30
+
 	put_bits(p, 1, 1); // marker
 	put_bits(p, 1, 0); // fixed vop rate = no
 	put_bits(p, 1, 1); // marker
@@ -450,10 +497,12 @@ static int __inline encode_vol_header(BW *p, M4V_VOL *vol)
 	put_bits(p, 1, 0); // sprite = disable
 	put_bits(p, 1, 0); // not8bit = false
 	put_bits(p, 1, 0); // quant type = H.263
+
 	put_bits(p, 1, 1); // complexity estimaition disable = true
 	put_bits(p, 1, 1); // resync marker disable = true
 	put_bits(p, 1, 0); // data pertitioning = false
 	put_bits(p, 1, 0); // scalability = false
+
 	m4v_stuffing(p);
 	return 0;
 }
@@ -461,14 +510,21 @@ static int __inline encode_vol_header(BW *p, M4V_VOL *vol)
 static int __inline encode_vop_header(BW *p, M4V_VOP *vop, int time_bits, int vop_not_coded)
 {
 //	static int time_old = 0;
+
 	int time_incr = vop->icount;
 	if (vop->time != 0)
 		time_incr = 0;
+
 	put_bits(p, 16, 0);
 	put_bits(p, 16, VOP_STARTCODE);
+
 	put_bits(p, 2, vop->picture_type);
+
+
 //	printf("not_code:%d vop_time: %d\n", vop_not_coded, vop->time);
+
 //	printf("pic:%d icount:%d vop_time: %d\n", vop->picture_type, time_incr, vop->time);
+
 	/*  if (time_old > vop->time)
 	    {
 	        put_bits(p, 1, 1);
@@ -476,54 +532,70 @@ static int __inline encode_vop_header(BW *p, M4V_VOP *vop, int time_bits, int vo
 
 	    time_old = vop->time;
 	*/
+
 	// !!!!!
 	while (time_incr--)
 		put_bits(p, 1, 1);
 	put_bits(p, 1, 0);
+
 	put_bits(p, 1, 1); // marker
 	put_bits(p, time_bits, vop->time); // time_increment
 	put_bits(p, 1, 1); // marker
+
 	if (vop_not_coded)
 	{
 		put_bits(p, 1, 0); // vop coded
 		return 0;
 	}
+
 	put_bits(p, 1, 1); // vop coded
+
 	if (vop->picture_type == M4V_P_TYPE)
 	{
 		put_bits(p, 1, vop->rounding_type); // rounding type
 	}
+
 	put_bits(p, 3, 0); // intra dc VLC threashold
+
 	put_bits(p, 5, vop->qscale); // qscale
+
 	if (vop->picture_type != M4V_I_TYPE)
 	{
 		put_bits(p, 3, vop->f_code);
 	}
+
 	if (vop->picture_type == M4V_B_TYPE)
 	{
 		put_bits(p, 3, vop->b_code);
 	}
+
 	return 0;
 }
 
 static __inline int encode_gop_header(BW *bw, uint32 time_ms)
 {
 	int sec, min, hour;
+
 	sec = time_ms / 1000;
 	min = sec / 60;
 	sec %= 60;
 	hour = min / 60;
 	min %= 60;
 	hour %= 24;
+
 	put_bits(bw, 16, 0);
 	put_bits(bw, 16, GOP_STARTCODE);
+
 	put_bits(bw, 5, hour);
 	put_bits(bw, 6, min);
 	put_bits(bw, 1, 1);
 	put_bits(bw, 6, sec);
+
 	put_bits(bw, 1, 0); // closed_gop == NO
 	put_bits(bw, 1, 0); // broken link == NO
+
 	printf("GOP %02d:%02d:%02d\n", hour, min, sec);
+
 	m4v_stuffing(bw);
 	return 0;
 }
@@ -532,6 +604,7 @@ static int __inline encode_user_header(BW *p)
 {
 	put_bits(p, 16, 0);
 	put_bits(p, 16, USERDATA_STARTCODE);
+
 	put_bits(p, 8, 'v');
 	put_bits(p, 8, 'i');
 	put_bits(p, 8, 'x');
@@ -540,6 +613,7 @@ static int __inline encode_user_header(BW *p)
 	put_bits(p, 8, 'n');
 	put_bits(p, 8, 'e');
 	put_bits(p, 8, 't');
+
 	m4v_stuffing(p);
 	return 0;
 }
@@ -575,6 +649,7 @@ void m4v_encode_P_mb(BW *bw, M4V_MICROBLOCK *mb)
 	{
 		put_bits(bw, 1, 0); // coded
 	}
+
 	if (mb->intra)
 	{
 		encode_mb_intra_internal(bw, mb, 0);
@@ -592,6 +667,7 @@ int m4v_encode_I_dcpred(M4V_MICROBLOCK *mb, M4V_DCPRED *dcpred, int mb_x, int mb
 	{
 		dcpred_set_qscale(dcpred, mb->qscale);
 		dcpred_set_pos(dcpred, mb_x, mb_y);
+
 		for (n = 0; n < 6; n ++)
 		{
 			int level = dcpred_for_enc(dcpred, n, mb->block[n].block[0]);