/*
*
* This file is part of libmpeg3
*
* LibMPEG3
* Author: Adam Williams <broadcast@earthling.net>
* Page: heroine.linuxbox.com
* Page: http://www.smalltalkconsulting.com/html/mpeg3source.html (for Squeak)
*
LibMPEG3 was originally licenced under GPL. It was relicensed by
the author under the LGPL and the Squeak license on Nov 1st, 2000
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also licensed under the Squeak license.
http://www.squeak.org/license.html
*/
#include "mpeg3video.h"
#include "slice.h"
#include "vlc.h"
#include <stdio.h>
int mpeg3video_get_macroblock_address(mpeg3_slice_t *slice)
{
int code, val = 0;
mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
while((code = mpeg3slice_showbits(slice_buffer, 11)) < 24)
{
/* Is not macroblock_stuffing */
if(code != 15)
{
/* Is macroblock_escape */
if(code == 8)
{
val += 33;
}
else
{
/* fprintf(stderr, "mpeg3video_get_macroblock_address: invalid macroblock_address_increment code\n"); */
slice->fault = 1;
return 1;
}
}
mpeg3slice_flushbits(slice_buffer, 11);
}
if(code >= 1024)
{
mpeg3slice_flushbit(slice_buffer);
return val + 1;
}
if(code >= 128)
{
code >>= 6;
mpeg3slice_flushbits(slice_buffer, mpeg3_MBAtab1[code].len);
return val + mpeg3_MBAtab1[code].val;
}
code -= 24;
mpeg3slice_flushbits(slice_buffer, mpeg3_MBAtab2[code].len);
return val + mpeg3_MBAtab2[code].val;
}
/* macroblock_type for pictures with spatial scalability */
static inline int mpeg3video_getsp_imb_type(mpeg3_slice_t *slice)
{
mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
unsigned int code = mpeg3slice_showbits(slice_buffer, 4);
if(!code)
{
/* fprintf(stderr,"mpeg3video_getsp_imb_type: invalid macroblock_type code\n"); */
slice->fault = 1;
return 0;
}
mpeg3slice_flushbits(slice_buffer, mpeg3_spIMBtab[code].len);
return mpeg3_spIMBtab[code].val;
}
static inline int mpeg3video_getsp_pmb_type(mpeg3_slice_t *slice)
{
mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
int code = mpeg3slice_showbits(slice_buffer, 7);
if(code < 2)
{
/* fprintf(stderr,"mpeg3video_getsp_pmb_type: invalid macroblock_type code\n"); */
slice->fault = 1;
return 0;
}
if(code >= 16)
{
code >>= 3;
mpeg3slice_flushbits(slice_buffer, mpeg3_spPMBtab0[code].len);
return mpeg3_spPMBtab0[code].val;
}
mpeg3slice_flushbits(slice_buffer, mpeg3_spPMBtab1[code].len);
return mpeg3_spPMBtab1[code].val;
}
static inline int mpeg3video_getsp_bmb_type(mpeg3_slice_t *slice)
{
mpeg3_VLCtab_t *p;
mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
int code = mpeg3slice_showbits9(slice_buffer);
if(code >= 64)
p = &mpeg3_spBMBtab0[(code >> 5) - 2];
else
if(code >= 16)
p = &mpeg3_spBMBtab1[(code >> 2) - 4];
else
if(code >= 8)
p = &mpeg3_spBMBtab2[code - 8];
else
{
/* fprintf(stderr,"mpeg3video_getsp_bmb_type: invalid macroblock_type code\n"); */
slice->fault = 1;
return 0;
}
mpeg3slice_flushbits(slice_buffer, p->len);
return p->val;
}
static inline int mpeg3video_get_imb_type(mpeg3_slice_t *slice)
{
mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
if(mpeg3slice_getbit(slice_buffer))
{
return 1;
}
if(!mpeg3slice_getbit(slice_buffer))
{
/* fprintf(stderr,"mpeg3video_get_imb_type: invalid macroblock_type code\n"); */
slice->fault = 1;
}
return 17;
}
static inline int mpeg3video_get_pmb_type(mpeg3_slice_t *slice)
{
int code;
mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
if((code = mpeg3slice_showbits(slice_buffer, 6)) >= 8)
{
code >>= 3;
mpeg3slice_flushbits(slice_buffer, mpeg3_PMBtab0[code].len);
return mpeg3_PMBtab0[code].val;
}
if(code == 0)
{
/* fprintf(stderr,"mpeg3video_get_pmb_type: invalid macroblock_type code\n"); */
slice->fault = 1;
return 0;
}
mpeg3slice_flushbits(slice_buffer, mpeg3_PMBtab1[code].len);
return mpeg3_PMBtab1[code].val;
}
static inline int mpeg3video_get_bmb_type(mpeg3_slice_t *slice)
{
int code;
mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
if((code = mpeg3slice_showbits(slice_buffer, 6)) >= 8)
{
code >>= 2;
mpeg3slice_flushbits(slice_buffer, mpeg3_BMBtab0[code].len);
return mpeg3_BMBtab0[code].val;
}
if(code == 0)
{
/* fprintf(stderr,"mpeg3video_get_bmb_type: invalid macroblock_type code\n"); */
slice->fault = 1;
return 0;
}
mpeg3slice_flushbits(slice_buffer, mpeg3_BMBtab1[code].len);
return mpeg3_BMBtab1[code].val;
}
static inline int mpeg3video_get_dmb_type(mpeg3_slice_t *slice)
{
if(!mpeg3slice_getbit(slice->slice_buffer))
{
/* fprintf(stderr,"mpeg3video_get_dmb_type: invalid macroblock_type code\n"); */
slice->fault=1;
}
return 1;
}
static inline int mpeg3video_get_snrmb_type(mpeg3_slice_t *slice)
{
mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
int code = mpeg3slice_showbits(slice_buffer, 3);
if(code == 0)
{
/* fprintf(stderr,"mpeg3video_get_snrmb_type: invalid macroblock_type code\n"); */
slice->fault = 1;
return 0;
}
mpeg3slice_flushbits(slice_buffer, mpeg3_SNRMBtab[code].len);
return mpeg3_SNRMBtab[code].val;
}
int mpeg3video_get_mb_type(mpeg3_slice_t *slice, mpeg3video_t *video)
{
if(video->scalable_mode == SC_SNR)
{
return mpeg3video_get_snrmb_type(slice);
}
else
{
switch(video->pict_type)
{
case I_TYPE: return video->pict_scal ? mpeg3video_getsp_imb_type(slice) : mpeg3video_get_imb_type(slice);
case P_TYPE: return video->pict_scal ? mpeg3video_getsp_pmb_type(slice) : mpeg3video_get_pmb_type(slice);
case B_TYPE: return video->pict_scal ? mpeg3video_getsp_bmb_type(slice) : mpeg3video_get_bmb_type(slice);
case D_TYPE: return mpeg3video_get_dmb_type(slice);
default:
/*fprintf(stderr, "mpeg3video_getmbtype: unknown coding type\n"); */
break;
/* MPEG-1 only, not implemented */
}
}
return 0;
}
int mpeg3video_macroblock_modes(mpeg3_slice_t *slice,
mpeg3video_t *video,
int *pmb_type,
int *pstwtype,
int *pstwclass,
int *pmotion_type,
int *pmv_count,
int *pmv_format,
int *pdmv,
int *pmvscale,
int *pdct_type)
{
int mb_type;
int stwtype, stwcode, stwclass;
int motion_type = 0, mv_count, mv_format, dmv, mvscale;
int dct_type;
mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
static unsigned char stwc_table[3][4]
= { {6,3,7,4}, {2,1,5,4}, {2,5,7,4} };
static unsigned char stwclass_table[9]
= {0, 1, 2, 1, 1, 2, 3, 3, 4};
/* get macroblock_type */
mb_type = mpeg3video_get_mb_type(slice, video);
if(slice->fault) return 1;
/* get spatial_temporal_weight_code */
if(mb_type & MB_WEIGHT)
{
if(video->stwc_table_index == 0)
stwtype = 4;
else
{
stwcode = mpeg3slice_getbits2(slice_buffer);
stwtype = stwc_table[video->stwc_table_index - 1][stwcode];
}
}
else
stwtype = (mb_type & MB_CLASS4) ? 8 : 0;
/* derive spatial_temporal_weight_class (Table 7-18) */
stwclass = stwclass_table[stwtype];
/* get frame/field motion type */
if(mb_type & (MB_FORWARD | MB_BACKWARD))
{
if(video->pict_struct == FRAME_PICTURE)
{
/* frame_motion_type */
motion_type = video->frame_pred_dct ? MC_FRAME : mpeg3slice_getbits2(slice_buffer);
}
else
{
/* field_motion_type */
motion_type = mpeg3slice_getbits2(slice_buffer);
}
}
else
if((mb_type & MB_INTRA) && video->conceal_mv)
{
/* concealment motion vectors */
motion_type = (video->pict_struct == FRAME_PICTURE) ? MC_FRAME : MC_FIELD;
}
/* derive mv_count, mv_format and dmv, (table 6-17, 6-18) */
if(video->pict_struct == FRAME_PICTURE)
{
mv_count = (motion_type == MC_FIELD && stwclass < 2) ? 2 : 1;
mv_format = (motion_type == MC_FRAME) ? MV_FRAME : MV_FIELD;
}
else
{
mv_count = (motion_type == MC_16X8) ? 2 : 1;
mv_format = MV_FIELD;
}
dmv = (motion_type == MC_DMV); /* dual prime */
/* field mv predictions in frame pictures have to be scaled */
mvscale = ((mv_format == MV_FIELD) && (video->pict_struct == FRAME_PICTURE));
/* get dct_type (frame DCT / field DCT) */
dct_type = (video->pict_struct == FRAME_PICTURE) &&
(!video->frame_pred_dct) &&
(mb_type & (MB_PATTERN | MB_INTRA)) ?
mpeg3slice_getbit(slice_buffer) : 0;
/* return values */
*pmb_type = mb_type;
*pstwtype = stwtype;
*pstwclass = stwclass;
*pmotion_type = motion_type;
*pmv_count = mv_count;
*pmv_format = mv_format;
*pdmv = dmv;
*pmvscale = mvscale;
*pdct_type = dct_type;
return 0;
}
|