/* don't understand why they choose a different header ! */
int ff_intel_h263_decode_picture_header(MpegEncContext *s)
{
int format;
/* picture header */
if (get_bits_long(&s->gb, 22) != 0x20) {
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
return -1;
}
s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
if (get_bits1(&s->gb) != 1) {
av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n");
return -1; /* marker */
}
if (get_bits1(&s->gb) != 0) {
av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n");
return -1; /* h263 id */
}
skip_bits1(&s->gb); /* split screen off */
skip_bits1(&s->gb); /* camera off */
skip_bits1(&s->gb); /* freeze picture release off */
format = get_bits(&s->gb, 3);
if (format == 0 || format == 6) {
av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n");
return -1;
}
s->h263_plus = 0;
s->pict_type = AV_PICTURE_TYPE_I + get_bits1(&s->gb);
s->unrestricted_mv = get_bits1(&s->gb);
s->h263_long_vectors = s->unrestricted_mv;
if (get_bits1(&s->gb) != 0) {
av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n");
return -1; /* SAC: off */
}
s->obmc= get_bits1(&s->gb);
s->pb_frame = get_bits1(&s->gb);
if (format < 6) {
s->width = ff_h263_format[format][0];
s->height = ff_h263_format[format][1];
s->avctx->sample_aspect_ratio.num = 12;
s->avctx->sample_aspect_ratio.den = 11;
} else {
format = get_bits(&s->gb, 3);
if(format == 0 || format == 7){
av_log(s->avctx, AV_LOG_ERROR, "Wrong Intel H263 format\n");
return -1;
}
if(get_bits(&s->gb, 2))
av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n");
s->loop_filter = get_bits1(&s->gb);
if(get_bits1(&s->gb))
av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n");
if(get_bits1(&s->gb))
s->pb_frame = 2;
if(get_bits(&s->gb, 5))
av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n");
if(get_bits(&s->gb, 5) != 1)
av_log(s->avctx, AV_LOG_ERROR, "Invalid marker\n");
}
if(format == 6){
int ar = get_bits(&s->gb, 4);
skip_bits(&s->gb, 9); // display width
skip_bits1(&s->gb);
skip_bits(&s->gb, 9); // display height
if(ar == 15){
s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 8); // aspect ratio - width
s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 8); // aspect ratio - height
} else {
s->avctx->sample_aspect_ratio = ff_h263_pixel_aspect[ar];
}
if (s->avctx->sample_aspect_ratio.num == 0)
av_log(s->avctx, AV_LOG_ERROR, "Invalid aspect ratio.\n");
}
s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
if(s->pb_frame){
skip_bits(&s->gb, 3); //temporal reference for B-frame
skip_bits(&s->gb, 2); //dbquant
}
/* PEI */
while (get_bits1(&s->gb) != 0) {
skip_bits(&s->gb, 8);
}
s->f_code = 1;
s->y_dc_scale_table=
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
ff_h263_show_pict_info(s);
return 0;
}
int ff_h264_decode_ref_pic_marking(H264Context *h, GetBitContext *gb,
int first_slice)
{
int i, ret;
MMCO mmco_temp[MAX_MMCO_COUNT], *mmco = mmco_temp;
int mmco_index = 0;
if (h->nal_unit_type == NAL_IDR_SLICE) { // FIXME fields
skip_bits1(gb); // broken_link
if (get_bits1(gb)) {
mmco[0].opcode = MMCO_LONG;
mmco[0].long_arg = 0;
mmco_index = 1;
}
} else {
if (get_bits1(gb)) { // adaptive_ref_pic_marking_mode_flag
for (i = 0; i < MAX_MMCO_COUNT; i++) {
MMCOOpcode opcode = get_ue_golomb_31(gb);
mmco[i].opcode = opcode;
if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) {
mmco[i].short_pic_num =
(h->curr_pic_num - get_ue_golomb(gb) - 1) &
(h->max_pic_num - 1);
#if 0
if (mmco[i].short_pic_num >= h->short_ref_count ||
h->short_ref[ mmco[i].short_pic_num ] == NULL) {
av_log(s->avctx, AV_LOG_ERROR,
"illegal short ref in memory management control "
"operation %d\n", mmco);
return -1;
}
#endif
}
if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) {
unsigned int long_arg = get_ue_golomb_31(gb);
if (long_arg >= 32 ||
(long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG &&
long_arg == 16) &&
!(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE(h)))) {
av_log(h->avctx, AV_LOG_ERROR,
"illegal long ref in memory management control "
"operation %d\n", opcode);
return -1;
}
mmco[i].long_arg = long_arg;
}
if (opcode > (unsigned) MMCO_LONG) {
av_log(h->avctx, AV_LOG_ERROR,
"illegal memory management control operation %d\n",
opcode);
return -1;
}
if (opcode == MMCO_END)
break;
}
mmco_index = i;
} else {
if (first_slice) {
ret = ff_generate_sliding_window_mmcos(h, first_slice);
if (ret < 0 && h->avctx->err_recognition & AV_EF_EXPLODE)
return ret;
}
mmco_index = -1;
}
}
if (first_slice && mmco_index != -1) {
memcpy(h->mmco, mmco_temp, sizeof(h->mmco));
h->mmco_index = mmco_index;
} else if (!first_slice && mmco_index >= 0 &&
(mmco_index != h->mmco_index ||
check_opcodes(h->mmco, mmco_temp, mmco_index))) {
av_log(h->avctx, AV_LOG_ERROR,
"Inconsistent MMCO state between slices [%d, %d]\n",
mmco_index, h->mmco_index);
return AVERROR_INVALIDDATA;
}
return 0;
}
/**
* decodes the H261 picture header.
* @return <0 if no startcode found
*/
static int h261_decode_picture_header(H261Context *h){
MpegEncContext * const s = &h->s;
int format, i;
uint32_t startcode= 0;
for(i= get_bits_left(&s->gb); i>24; i-=1){
startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF;
if(startcode == 0x10)
break;
}
if (startcode != 0x10){
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
return -1;
}
/* temporal reference */
i= get_bits(&s->gb, 5); /* picture timestamp */
if(i < (s->picture_number&31))
i += 32;
s->picture_number = (s->picture_number&~31) + i;
#ifndef _MSC_VER
s->avctx->time_base= (AVRational){1001, 30000};
#else
//MSVC
s->avctx->time_base= av_create_rational(1001, 30000);
#endif
s->current_picture.pts= s->picture_number;
/* PTYPE starts here */
skip_bits1(&s->gb); /* split screen off */
skip_bits1(&s->gb); /* camera off */
skip_bits1(&s->gb); /* freeze picture release off */
format = get_bits1(&s->gb);
//only 2 formats possible
if (format == 0){//QCIF
s->width = 176;
s->height = 144;
s->mb_width = 11;
s->mb_height = 9;
}else{//CIF
s->width = 352;
s->height = 288;
s->mb_width = 22;
s->mb_height = 18;
}
s->mb_num = s->mb_width * s->mb_height;
skip_bits1(&s->gb); /* still image mode off */
skip_bits1(&s->gb); /* Reserved */
/* PEI */
while (get_bits1(&s->gb) != 0){
skip_bits(&s->gb, 8);
}
// h261 has no I-FRAMES, but if we pass FF_I_TYPE for the first frame, the codec crashes if it does
// not contain all I-blocks (e.g. when a packet is lost)
s->pict_type = FF_P_TYPE;
h->gob_number = 0;
return 0;
}
/* most is hardcoded. should extend to handle all h263 streams */
static int h263_decode_picture_header(unsigned char *b_ptr)
{
int i;
for(i=0;i<16;i++) printf(" %02X",b_ptr[i]); printf("\n");
buffer=b_ptr;
bufptr=bitcnt=buf=0;
/* picture header */
if (get_bits(&s->gb, 22) != 0x20){
printf("bad picture header\n");
return -1;
}
skip_bits(&s->gb, 8); /* picture timestamp */
if (get_bits1(&s->gb) != 1){
printf("bad marker\n");
return -1; /* marker */
}
if (get_bits1(&s->gb) != 0){
printf("bad h263 id\n");
return -1; /* h263 id */
}
skip_bits1(&s->gb); /* split screen off */
skip_bits1(&s->gb); /* camera off */
skip_bits1(&s->gb); /* freeze picture release off */
format = get_bits(&s->gb, 3);
if (format != 7) {
printf("h263_plus = 0 format = %d\n",format);
/* H.263v1 */
width = h263_format[format][0];
height = h263_format[format][1];
printf("%d x %d\n",width,height);
// if (!width) return -1;
printf("pict_type=%d\n",get_bits1(&s->gb));
printf("unrestricted_mv=%d\n",get_bits1(&s->gb));
#if 1
printf("SAC: %d\n",get_bits1(&s->gb));
printf("advanced prediction mode: %d\n",get_bits1(&s->gb));
printf("PB frame: %d\n",get_bits1(&s->gb));
#else
if (get_bits1(&s->gb) != 0)
return -1; /* SAC: off */
if (get_bits1(&s->gb) != 0)
return -1; /* advanced prediction mode: off */
if (get_bits1(&s->gb) != 0)
return -1; /* not PB frame */
#endif
printf("qscale=%d\n",get_bits(&s->gb, 5));
skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
} else {
printf("h263_plus = 1\n");
/* H.263v2 */
if (get_bits(&s->gb, 3) != 1){
printf("H.263v2 A error\n");
return -1;
}
if (get_bits(&s->gb, 3) != 6){ /* custom source format */
printf("custom source format\n");
return -1;
}
skip_bits(&s->gb, 12);
skip_bits(&s->gb, 3);
printf("pict_type=%d\n",get_bits(&s->gb, 3) + 1);
// if (s->pict_type != I_TYPE &&
// s->pict_type != P_TYPE)
// return -1;
skip_bits(&s->gb, 7);
skip_bits(&s->gb, 4); /* aspect ratio */
width = (get_bits(&s->gb, 9) + 1) * 4;
skip_bits1(&s->gb);
height = get_bits(&s->gb, 9) * 4;
printf("%d x %d\n",width,height);
//if (height == 0)
// return -1;
printf("qscale=%d\n",get_bits(&s->gb, 5));
}
/* PEI */
while (get_bits1(&s->gb) != 0) {
skip_bits(&s->gb, 8);
}
// s->f_code = 1;
// s->width = width;
// s->height = height;
return 0;
}
/**
* Decode Smacker audio data
*/
static int smka_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
AVFrame *frame = data;
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
GetBitContext gb;
HuffContext h[4] = { { 0 } };
VLC vlc[4] = { { 0 } };
int16_t *samples;
uint8_t *samples8;
int val;
int i, res, ret;
int unp_size;
int bits, stereo;
int pred[2] = {0, 0};
if (buf_size <= 4) {
av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
return AVERROR(EINVAL);
}
unp_size = AV_RL32(buf);
init_get_bits(&gb, buf + 4, (buf_size - 4) * 8);
if(!get_bits1(&gb)){
av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
*got_frame_ptr = 0;
return 1;
}
stereo = get_bits1(&gb);
bits = get_bits1(&gb);
if (stereo ^ (avctx->channels != 1)) {
av_log(avctx, AV_LOG_ERROR, "channels mismatch\n");
return AVERROR(EINVAL);
}
if (bits && avctx->sample_fmt == AV_SAMPLE_FMT_U8) {
av_log(avctx, AV_LOG_ERROR, "sample format mismatch\n");
return AVERROR(EINVAL);
}
/* get output buffer */
frame->nb_samples = unp_size / (avctx->channels * (bits + 1));
if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
samples = (int16_t *)frame->data[0];
samples8 = frame->data[0];
// Initialize
for(i = 0; i < (1 << (bits + stereo)); i++) {
h[i].length = 256;
h[i].maxlength = 0;
h[i].current = 0;
h[i].bits = av_mallocz(256 * 4);
h[i].lengths = av_mallocz(256 * sizeof(int));
h[i].values = av_mallocz(256 * sizeof(int));
if (!h[i].bits || !h[i].lengths || !h[i].values) {
ret = AVERROR(ENOMEM);
goto error;
}
skip_bits1(&gb);
if (smacker_decode_tree(&gb, &h[i], 0, 0) < 0) {
ret = AVERROR_INVALIDDATA;
goto error;
}
skip_bits1(&gb);
if(h[i].current > 1) {
res = init_vlc(&vlc[i], SMKTREE_BITS, h[i].length,
h[i].lengths, sizeof(int), sizeof(int),
h[i].bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
if(res < 0) {
av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
ret = AVERROR_INVALIDDATA;
goto error;
}
}
}
/* this codec relies on wraparound instead of clipping audio */
if(bits) { //decode 16-bit data
for(i = stereo; i >= 0; i--)
pred[i] = sign_extend(av_bswap16(get_bits(&gb, 16)), 16);
for(i = 0; i <= stereo; i++)
*samples++ = pred[i];
for(; i < unp_size / 2; i++) {
if(i & stereo) {
if(vlc[2].table)
res = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3);
else
res = 0;
val = h[2].values[res];
if(vlc[3].table)
res = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3);
else
res = 0;
val |= h[3].values[res] << 8;
pred[1] += sign_extend(val, 16);
*samples++ = pred[1];
} else {
if(vlc[0].table)
res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
else
res = 0;
val = h[0].values[res];
if(vlc[1].table)
res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
else
res = 0;
val |= h[1].values[res] << 8;
pred[0] += sign_extend(val, 16);
*samples++ = pred[0];
}
}
} else { //8-bit data
for(i = stereo; i >= 0; i--)
pred[i] = get_bits(&gb, 8);
for(i = 0; i <= stereo; i++)
*samples8++ = pred[i];
for(; i < unp_size; i++) {
if(i & stereo){
if(vlc[1].table)
res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
else
res = 0;
pred[1] += sign_extend(h[1].values[res], 8);
*samples8++ = pred[1];
} else {
if(vlc[0].table)
res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
else
res = 0;
pred[0] += sign_extend(h[0].values[res], 8);
*samples8++ = pred[0];
}
}
}
*got_frame_ptr = 1;
ret = buf_size;
error:
for(i = 0; i < 4; i++) {
if(vlc[i].table)
ff_free_vlc(&vlc[i]);
av_free(h[i].bits);
av_free(h[i].lengths);
av_free(h[i].values);
}
return ret;
}
/**
* Decode Smacker audio data
*/
static int smka_decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size)
{
GetBitContext gb;
HuffContext h[4];
VLC vlc[4];
int16_t *samples = data;
int val;
int i, res;
int unp_size;
int bits, stereo;
int pred[2] = {0, 0};
unp_size = AV_RL32(buf);
init_get_bits(&gb, buf + 4, (buf_size - 4) * 8);
if(!get_bits1(&gb)){
av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
*data_size = 0;
return 1;
}
stereo = get_bits1(&gb);
bits = get_bits1(&gb);
if (unp_size & 0xC0000000 || (unp_size << !bits) > *data_size) {
av_log(avctx, AV_LOG_ERROR, "Frame is too large to fit in buffer\n");
return -1;
}
memset(vlc, 0, sizeof(VLC) * 4);
memset(h, 0, sizeof(HuffContext) * 4);
// Initialize
for(i = 0; i < (1 << (bits + stereo)); i++) {
h[i].length = 256;
h[i].maxlength = 0;
h[i].current = 0;
h[i].bits = av_mallocz(256 * 4);
h[i].lengths = av_mallocz(256 * sizeof(int));
h[i].values = av_mallocz(256 * sizeof(int));
skip_bits1(&gb);
smacker_decode_tree(&gb, &h[i], 0, 0);
skip_bits1(&gb);
if(h[i].current > 1) {
res = init_vlc(&vlc[i], SMKTREE_BITS, h[i].length,
h[i].lengths, sizeof(int), sizeof(int),
h[i].bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
if(res < 0) {
av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
return -1;
}
}
}
if(bits) { //decode 16-bit data
for(i = stereo; i >= 0; i--)
pred[i] = bswap_16(get_bits(&gb, 16));
for(i = 0; i < stereo; i++)
*samples++ = pred[i];
for(i = 0; i < unp_size / 2; i++) {
if(i & stereo) {
if(vlc[2].table)
res = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3);
else
res = 0;
val = h[2].values[res];
if(vlc[3].table)
res = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3);
else
res = 0;
val |= h[3].values[res] << 8;
pred[1] += (int16_t)val;
*samples++ = pred[1];
} else {
if(vlc[0].table)
res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
else
res = 0;
val = h[0].values[res];
if(vlc[1].table)
res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
else
res = 0;
val |= h[1].values[res] << 8;
pred[0] += val;
*samples++ = pred[0];
}
}
} else { //8-bit data
for(i = stereo; i >= 0; i--)
pred[i] = get_bits(&gb, 8);
for(i = 0; i < stereo; i++)
*samples++ = (pred[i] - 0x80) << 8;
for(i = 0; i < unp_size; i++) {
if(i & stereo){
if(vlc[1].table)
res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
else
res = 0;
pred[1] += (int8_t)h[1].values[res];
*samples++ = (pred[1] - 0x80) << 8;
} else {
if(vlc[0].table)
res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
else
res = 0;
pred[0] += (int8_t)h[0].values[res];
*samples++ = (pred[0] - 0x80) << 8;
}
}
unp_size *= 2;
}
for(i = 0; i < 4; i++) {
if(vlc[i].table)
free_vlc(&vlc[i]);
if(h[i].bits)
av_free(h[i].bits);
if(h[i].lengths)
av_free(h[i].lengths);
if(h[i].values)
av_free(h[i].values);
}
*data_size = unp_size;
return buf_size;
}
static int parse_descriptor(DCAExssParser *s, DCAExssAsset *asset)
{
int i, j, drc_present, descr_size, descr_pos = get_bits_count(&s->gb);
// Size of audio asset descriptor in bytes
descr_size = get_bits(&s->gb, 9) + 1;
// Audio asset identifier
asset->asset_index = get_bits(&s->gb, 3);
//
// Per stream static metadata
//
if (s->static_fields_present) {
// Asset type descriptor presence
if (get_bits1(&s->gb))
// Asset type descriptor
skip_bits(&s->gb, 4);
// Language descriptor presence
if (get_bits1(&s->gb))
// Language descriptor
skip_bits(&s->gb, 24);
// Additional textual information presence
if (get_bits1(&s->gb)) {
// Byte size of additional text info
int text_size = get_bits(&s->gb, 10) + 1;
// Sanity check available size
if (get_bits_left(&s->gb) < text_size * 8)
return AVERROR_INVALIDDATA;
// Additional textual information string
skip_bits_long(&s->gb, text_size * 8);
}
// PCM bit resolution
asset->pcm_bit_res = get_bits(&s->gb, 5) + 1;
// Maximum sample rate
asset->max_sample_rate = ff_dca_sampling_freqs[get_bits(&s->gb, 4)];
// Total number of channels
asset->nchannels_total = get_bits(&s->gb, 8) + 1;
// One to one map channel to speakers
if (asset->one_to_one_map_ch_to_spkr = get_bits1(&s->gb)) {
int spkr_mask_nbits = 0;
int spkr_remap_nsets;
int nspeakers[8];
// Embedded stereo flag
asset->embedded_stereo = asset->nchannels_total > 2 && get_bits1(&s->gb);
// Embedded 6 channels flag
asset->embedded_6ch = asset->nchannels_total > 6 && get_bits1(&s->gb);
// Speaker mask enabled flag
if (asset->spkr_mask_enabled = get_bits1(&s->gb)) {
// Number of bits for speaker activity mask
spkr_mask_nbits = (get_bits(&s->gb, 2) + 1) << 2;
// Loudspeaker activity mask
asset->spkr_mask = get_bits(&s->gb, spkr_mask_nbits);
}
// Number of speaker remapping sets
if ((spkr_remap_nsets = get_bits(&s->gb, 3)) && !spkr_mask_nbits) {
av_log(s->avctx, AV_LOG_ERROR, "Speaker mask disabled yet there are remapping sets\n");
return AVERROR_INVALIDDATA;
}
// Standard loudspeaker layout mask
for (i = 0; i < spkr_remap_nsets; i++)
nspeakers[i] = ff_dca_count_chs_for_mask(get_bits(&s->gb, spkr_mask_nbits));
for (i = 0; i < spkr_remap_nsets; i++) {
// Number of channels to be decoded for speaker remapping
int nch_for_remaps = get_bits(&s->gb, 5) + 1;
for (j = 0; j < nspeakers[i]; j++) {
// Decoded channels to output speaker mapping mask
int remap_ch_mask = get_bits_long(&s->gb, nch_for_remaps);
// Loudspeaker remapping codes
skip_bits_long(&s->gb, av_popcount(remap_ch_mask) * 5);
}
}
} else {
asset->embedded_stereo = 0;
asset->embedded_6ch = 0;
asset->spkr_mask_enabled = 0;
asset->spkr_mask = 0;
// Representation type
asset->representation_type = get_bits(&s->gb, 3);
}
}
//
// DRC, DNC and mixing metadata
//
// Dynamic range coefficient presence flag
drc_present = get_bits1(&s->gb);
// Code for dynamic range coefficient
if (drc_present)
skip_bits(&s->gb, 8);
// Dialog normalization presence flag
if (get_bits1(&s->gb))
// Dialog normalization code
skip_bits(&s->gb, 5);
// DRC for stereo downmix
if (drc_present && asset->embedded_stereo)
skip_bits(&s->gb, 8);
// Mixing metadata presence flag
if (s->mix_metadata_enabled && get_bits1(&s->gb)) {
int nchannels_dmix;
// External mixing flag
skip_bits1(&s->gb);
// Post mixing / replacement gain adjustment
skip_bits(&s->gb, 6);
// DRC prior to mixing
if (get_bits(&s->gb, 2) == 3)
// Custom code for mixing DRC
skip_bits(&s->gb, 8);
else
// Limit for mixing DRC
skip_bits(&s->gb, 3);
// Scaling type for channels of main audio
// Scaling parameters of main audio
if (get_bits1(&s->gb))
for (i = 0; i < s->nmixoutconfigs; i++)
skip_bits_long(&s->gb, 6 * s->nmixoutchs[i]);
else
skip_bits_long(&s->gb, 6 * s->nmixoutconfigs);
nchannels_dmix = asset->nchannels_total;
if (asset->embedded_6ch)
nchannels_dmix += 6;
if (asset->embedded_stereo)
nchannels_dmix += 2;
for (i = 0; i < s->nmixoutconfigs; i++) {
if (!s->nmixoutchs[i]) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid speaker layout mask for mixing configuration\n");
return AVERROR_INVALIDDATA;
}
for (j = 0; j < nchannels_dmix; j++) {
// Mix output mask
int mix_map_mask = get_bits(&s->gb, s->nmixoutchs[i]);
// Mixing coefficients
skip_bits_long(&s->gb, av_popcount(mix_map_mask) * 6);
}
}
}
//
// Decoder navigation data
//
// Coding mode for the asset
asset->coding_mode = get_bits(&s->gb, 2);
// Coding components used in asset
switch (asset->coding_mode) {
case 0: // Coding mode that may contain multiple coding components
asset->extension_mask = get_bits(&s->gb, 12);
if (asset->extension_mask & DCA_EXSS_CORE) {
// Size of core component in extension substream
asset->core_size = get_bits(&s->gb, 14) + 1;
// Core sync word present flag
if (get_bits1(&s->gb))
// Core sync distance
skip_bits(&s->gb, 2);
}
if (asset->extension_mask & DCA_EXSS_XBR)
// Size of XBR extension in extension substream
asset->xbr_size = get_bits(&s->gb, 14) + 1;
if (asset->extension_mask & DCA_EXSS_XXCH)
// Size of XXCH extension in extension substream
asset->xxch_size = get_bits(&s->gb, 14) + 1;
if (asset->extension_mask & DCA_EXSS_X96)
// Size of X96 extension in extension substream
asset->x96_size = get_bits(&s->gb, 12) + 1;
if (asset->extension_mask & DCA_EXSS_LBR)
parse_lbr_parameters(s, asset);
if (asset->extension_mask & DCA_EXSS_XLL)
parse_xll_parameters(s, asset);
if (asset->extension_mask & DCA_EXSS_RSV1)
skip_bits(&s->gb, 16);
if (asset->extension_mask & DCA_EXSS_RSV2)
skip_bits(&s->gb, 16);
break;
case 1: // Loss-less coding mode without CBR component
asset->extension_mask = DCA_EXSS_XLL;
parse_xll_parameters(s, asset);
break;
case 2: // Low bit rate mode
asset->extension_mask = DCA_EXSS_LBR;
parse_lbr_parameters(s, asset);
break;
case 3: // Auxiliary coding mode
asset->extension_mask = 0;
// Size of auxiliary coded data
skip_bits(&s->gb, 14);
// Auxiliary codec identification
skip_bits(&s->gb, 8);
// Aux sync word present flag
if (get_bits1(&s->gb))
// Aux sync distance
skip_bits(&s->gb, 3);
break;
}
if (asset->extension_mask & DCA_EXSS_XLL)
// DTS-HD stream ID
asset->hd_stream_id = get_bits(&s->gb, 3);
// One to one mixing flag
// Per channel main audio scaling flag
// Main audio scaling codes
// Decode asset in secondary decoder flag
// Revision 2 DRC metadata
// Reserved
// Zero pad
if (ff_dca_seek_bits(&s->gb, descr_pos + descr_size * 8)) {
av_log(s->avctx, AV_LOG_ERROR, "Read past end of EXSS asset descriptor\n");
return AVERROR_INVALIDDATA;
}
return 0;
}
int ff_flv_decode_picture_header(MpegEncContext *s)
{
int format, width, height;
/* picture header */
if (get_bits_long(&s->gb, 17) != 1) {
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
return -1;
}
format = get_bits(&s->gb, 5);
if (format != 0 && format != 1) {
av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n");
return -1;
}
s->h263_flv = format+1;
s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
format = get_bits(&s->gb, 3);
switch (format) {
case 0:
width = get_bits(&s->gb, 8);
height = get_bits(&s->gb, 8);
break;
case 1:
width = get_bits(&s->gb, 16);
height = get_bits(&s->gb, 16);
break;
case 2:
width = 352;
height = 288;
break;
case 3:
width = 176;
height = 144;
break;
case 4:
width = 128;
height = 96;
break;
case 5:
width = 320;
height = 240;
break;
case 6:
width = 160;
height = 120;
break;
default:
width = height = 0;
break;
}
if(av_check_image_size(width, height, 0, s->avctx))
return -1;
s->width = width;
s->height = height;
s->pict_type = FF_I_TYPE + get_bits(&s->gb, 2);
s->dropable= s->pict_type > FF_P_TYPE;
if (s->dropable)
s->pict_type = FF_P_TYPE;
skip_bits1(&s->gb); /* deblocking flag */
s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
s->h263_plus = 0;
s->unrestricted_mv = 1;
s->h263_long_vectors = 0;
/* PEI */
while (get_bits1(&s->gb) != 0) {
skip_bits(&s->gb, 8);
}
s->f_code = 1;
if(s->avctx->debug & FF_DEBUG_PICT_INFO){
av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n",
s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number);
}
s->y_dc_scale_table=
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
return 0;
}
int parse_dts_header(DTSParserContext *pContext, DTSHeader *pHeader, uint8_t *pBuffer, unsigned uSize)
{
if(!pContext) return -1;
if(!pHeader) return -1;
unsigned ExtDescriptor = 0, ExtCoding = 0;
uint8_t dts_buffer[32 + FF_INPUT_BUFFER_PADDING_SIZE] = {0};
int ret = ff_dca_convert_bitstream(pBuffer, uSize, dts_buffer, 32);
bool is16be = (AV_RB32(pBuffer) == DCA_MARKER_RAW_BE);
/* Parse Core Header */
if (ret >= 0) {
pHeader->HasCore = 1;
GetBitContext *gb = pContext->gb;
init_get_bits(gb, dts_buffer, 32 << 3);
skip_bits_long(gb, 32); /* Sync code */
skip_bits1(gb); /* Frame type */
pHeader->SamplesPerBlock = get_bits(gb, 5) + 1; /* Samples deficit */
pHeader->CRCPresent = get_bits1(gb); /* CRC present */
pHeader->Blocks = get_bits(gb, 7) + 1; /* Number of Blocks */
pHeader->FrameSize = get_bits(gb, 14) + 1; /* Primary (core) Frame Size */
pHeader->ChannelLayout = get_bits(gb, 6); /* Channel configuration */
unsigned sample_index = get_bits(gb, 4); /* Sample frequency index */
pHeader->SampleRate = avpriv_dca_sample_rates[sample_index];
unsigned bitrate_index = get_bits(gb, 5); /* Bitrate index */
pHeader->Bitrate = dca_bit_rates[bitrate_index];
skip_bits1(gb); /* Down mix */
skip_bits1(gb); /* Dynamic range */
skip_bits1(gb); /* Time stamp */
skip_bits1(gb); /* Auxiliary data */
skip_bits1(gb); /* HDCD */
ExtDescriptor = get_bits(gb, 3); /* External descriptor */
ExtCoding = get_bits1(gb); /* Extended coding */
skip_bits1(gb); /* ASPF */
pHeader->LFE = get_bits(gb, 2); /* LFE */
skip_bits1(gb); /* Predictor History */
if(pHeader->CRCPresent)
skip_bits(gb, 16); /* CRC */
skip_bits1(gb); /* Multirate Interpolator */
skip_bits(gb, 4); /* Encoder Software Revision */
skip_bits(gb, 2); /* Copy history */
pHeader->ES = get_bits1(gb); /* ES */
skip_bits(gb, 2); /* PCMR (source PCM resolution) */
skip_bits1(gb); /* SUMF (Front Sum/Difference Flag) */
skip_bits1(gb); /* SUMS (Surround Sum/Difference Flag) */
skip_bits(gb, 4); /* Dialog Normalization Parameter or Unspecified (dependent on encoder version) */
} else {
pHeader->HasCore = 0;
}
if (pHeader->HasCore && !is16be)
return 0;
// DTS-HD parsing
const uint8_t *pHD = NULL;
if (pHeader->HasCore) { // If we have a core, only search after the normal buffer
if (uSize > (pHeader->FrameSize + 4)) { // at least 4 bytes extra, could probably insert a minimal size of a HD header, but so what
pHD = find_marker32_position(pBuffer + pHeader->FrameSize, uSize - pHeader->FrameSize, DCA_HD_MARKER);
}
} else {
pHD = find_marker32_position(pBuffer, uSize, DCA_HD_MARKER);
}
if (pHD) {
pHeader->IsHD = 1;
size_t remaining = uSize - (pHD - pBuffer);
parse_dts_hd_header(pContext, pHeader, pHD, (unsigned)remaining);
const uint8_t *pXChHD = find_marker32_position(pHD, remaining, DCA_XCH_MARKER);
if (pXChHD) {
size_t remaining = uSize - (pXChHD - pBuffer);
parse_dts_xch_hd_header(pContext, pHeader, pXChHD, (unsigned)remaining);
}
const uint8_t *pXXChHD = find_marker32_position(pHD, remaining, DCA_XXCH_MARKER);
if (pXXChHD) {
size_t remaining = uSize - (pXXChHD - pBuffer);
parse_dts_xxch_hd_header(pContext, pHeader, pXXChHD, (unsigned)remaining);
}
}
// Handle DTS extensions
if (ExtCoding) {
size_t coreSize = pHD ? (pHD - pBuffer) : uSize;
if (ExtDescriptor == 0 || ExtDescriptor == 3) {
const uint8_t *pXCh = find_marker32_position(pBuffer, coreSize, DCA_XCH_MARKER);
if (pXCh) {
size_t remaining = coreSize - (pXCh - pBuffer);
parse_dts_xch_header(pContext, pHeader, pXCh, (unsigned)remaining);
}
}
if (ExtDescriptor == 6) {
const uint8_t *pXXCh = find_marker32_position(pBuffer, coreSize, DCA_XXCH_MARKER);
if (pXXCh) {
size_t remaining = coreSize - (pXXCh - pBuffer);
parse_dts_xxch_header(pContext, pHeader, pXXCh, (unsigned)remaining);
}
}
}
return 0;
}
/*
Extract width & height from vol header passed as arg
*/
uint8_t extractMpeg4Info(uint8_t *data,uint32_t dataSize,uint32_t *w,uint32_t *h,uint32_t *time_inc)
{
// Search startcode
uint8_t b;
uint32_t idx=0;
uint32_t mw,mh;
uint32_t timeVal;
//mixDump(data,dataSize);
//printf("\n");
while(1)
{
uint32_t startcode=0xffffffff;
while(dataSize>2)
{
startcode=(startcode<<8)+data[idx];
idx++;
dataSize--;
if((startcode&0xffffff)==1) break;
}
if(dataSize>2)
{
//printf("Startcodec:%x\n",data[idx]);
if((data[idx]&0xF0)==0x20) //VOL start
{
dataSize--;
idx++;
#if 0
printf("VOL Header:\n");
if(dataSize<16)
{
mixDump(data+idx,dataSize);
printf("\n");
}
else
{
mixDump(data+idx,16);
printf("\n");
}
#endif
// Here we go !
GetBitContext s;
init_get_bits( &s,data+idx, dataSize*8);
//
skip_bits1(&s); // Random access
skip_bits(&s,8); // Obj type indication
if(get_bits(&s,1)) // VO od
{
skip_bits(&s,4); // Ver
skip_bits(&s,3); // Priority
}
if(get_bits(&s,4)==15) // custom A/R
{
skip_bits(&s,8);
skip_bits(&s,8);
}
if(get_bits(&s,1)) // Vol control param
{
skip_bits(&s,2); //Chroma
skip_bits(&s,1); // Low delay
if(get_bits(&s,1)) // VBV Info
{
skip_bits(&s,16);
skip_bits(&s,16);
skip_bits(&s,16);
skip_bits(&s,15);
skip_bits(&s,16);
}
}
skip_bits(&s,2); // Shape
skip_bits(&s,1); // Marker
timeVal=get_bits(&s,16); // Time increment
*time_inc = av_log2(timeVal - 1) + 1;
if (*time_inc < 1)
*time_inc = 1;
skip_bits(&s,1); // Marker
if(get_bits(&s,1)) // Fixed vop rate, compute how much bits needed
{
get_bits(&s, *time_inc);
}
skip_bits(&s,1); // Marker
mw=get_bits(&s,13);
skip_bits(&s,1); // Marker
mh=get_bits(&s,13);
// /Here we go
//printf("%d x %d \n",mw,mh);
*h=mh;
*w=mw;
return 1;;
// Free get bits ?
// WTF ?
}
continue;
}
else
{
printf("No more startcode\n");
// Free get bits ?
return 0;
}
}
return 0;
}
/**
* Decode the H.261 picture header.
* @return <0 if no startcode found
*/
static int h261_decode_picture_header(H261Context *h)
{
MpegEncContext *const s = &h->s;
int format, i;
uint32_t startcode = 0;
for (i = get_bits_left(&s->gb); i > 24; i -= 1) {
startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF;
if (startcode == 0x10)
break;
}
if (startcode != 0x10) {
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
return -1;
}
/* temporal reference */
i = get_bits(&s->gb, 5); /* picture timestamp */
if (i < (s->picture_number & 31))
i += 32;
s->picture_number = (s->picture_number & ~31) + i;
#ifdef IDE_COMPILE
s->avctx->time_base.num = 1001;
s->avctx->time_base.den = 30000;
#else
s->avctx->time_base = (AVRational) { 1001, 30000 };
#endif
/* PTYPE starts here */
skip_bits1(&s->gb); /* split screen off */
skip_bits1(&s->gb); /* camera off */
skip_bits1(&s->gb); /* freeze picture release off */
format = get_bits1(&s->gb);
// only 2 formats possible
if (format == 0) { // QCIF
s->width = 176;
s->height = 144;
s->mb_width = 11;
s->mb_height = 9;
} else { // CIF
s->width = 352;
s->height = 288;
s->mb_width = 22;
s->mb_height = 18;
}
s->mb_num = s->mb_width * s->mb_height;
skip_bits1(&s->gb); /* still image mode off */
skip_bits1(&s->gb); /* Reserved */
/* PEI */
if (skip_1stop_8data_bits(&s->gb) < 0)
return AVERROR_INVALIDDATA;
/* H.261 has no I-frames, but if we pass AV_PICTURE_TYPE_I for the first
* frame, the codec crashes if it does not contain all I-blocks
* (e.g. when a packet is lost). */
s->pict_type = AV_PICTURE_TYPE_P;
h->gob_number = 0;
return 0;
}
/**
* Decode Smacker audio data
*/
static int smka_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
GetBitContext gb;
HuffContext h[4];
VLC vlc[4];
int16_t *samples = data;
uint8_t *samples8 = data;
int val;
int i, res;
int unp_size;
int bits, stereo;
int pred[2] = {0, 0};
if (buf_size <= 4) {
av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
return AVERROR(EINVAL);
}
unp_size = AV_RL32(buf);
init_get_bits(&gb, buf + 4, (buf_size - 4) * 8);
if(!get_bits1(&gb)){
av_log(avctx, AV_LOG_INFO, "Sound: no data\n");
*data_size = 0;
return 1;
}
stereo = get_bits1(&gb);
bits = get_bits1(&gb);
if (unp_size & 0xC0000000 || unp_size > *data_size) {
av_log(avctx, AV_LOG_ERROR, "Frame is too large to fit in buffer\n");
return -1;
}
if (stereo ^ (avctx->channels != 1)) {
av_log(avctx, AV_LOG_ERROR, "channels mismatch\n");
return AVERROR(EINVAL);
}
if (bits && avctx->sample_fmt == AV_SAMPLE_FMT_U8) {
av_log(avctx, AV_LOG_ERROR, "sample format mismatch\n");
return AVERROR(EINVAL);
}
memset(vlc, 0, sizeof(VLC) * 4);
memset(h, 0, sizeof(HuffContext) * 4);
// Initialize
for(i = 0; i < (1 << (bits + stereo)); i++) {
h[i].length = 256;
h[i].maxlength = 0;
h[i].current = 0;
h[i].bits = av_mallocz(256 * 4);
h[i].lengths = av_mallocz(256 * sizeof(int));
h[i].values = av_mallocz(256 * sizeof(int));
skip_bits1(&gb);
smacker_decode_tree(&gb, &h[i], 0, 0);
skip_bits1(&gb);
if(h[i].current > 1) {
res = init_vlc(&vlc[i], SMKTREE_BITS, h[i].length,
h[i].lengths, sizeof(int), sizeof(int),
h[i].bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
if(res < 0) {
av_log(avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
return -1;
}
}
}
if(bits) { //decode 16-bit data
for(i = stereo; i >= 0; i--)
pred[i] = av_bswap16(get_bits(&gb, 16));
for(i = 0; i <= stereo; i++)
*samples++ = pred[i];
for(; i < unp_size / 2; i++) {
if(i & stereo) {
if(vlc[2].table)
res = get_vlc2(&gb, vlc[2].table, SMKTREE_BITS, 3);
else
res = 0;
val = h[2].values[res];
if(vlc[3].table)
res = get_vlc2(&gb, vlc[3].table, SMKTREE_BITS, 3);
else
res = 0;
val |= h[3].values[res] << 8;
pred[1] += sign_extend(val, 16);
*samples++ = av_clip_int16(pred[1]);
} else {
if(vlc[0].table)
res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
else
res = 0;
val = h[0].values[res];
if(vlc[1].table)
res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
else
res = 0;
val |= h[1].values[res] << 8;
pred[0] += sign_extend(val, 16);
*samples++ = av_clip_int16(pred[0]);
}
}
} else { //8-bit data
for(i = stereo; i >= 0; i--)
pred[i] = get_bits(&gb, 8);
for(i = 0; i <= stereo; i++)
*samples8++ = pred[i];
for(; i < unp_size; i++) {
if(i & stereo){
if(vlc[1].table)
res = get_vlc2(&gb, vlc[1].table, SMKTREE_BITS, 3);
else
res = 0;
pred[1] += sign_extend(h[1].values[res], 8);
*samples8++ = av_clip_uint8(pred[1]);
} else {
if(vlc[0].table)
res = get_vlc2(&gb, vlc[0].table, SMKTREE_BITS, 3);
else
res = 0;
pred[0] += sign_extend(h[0].values[res], 8);
*samples8++ = av_clip_uint8(pred[0]);
}
}
}
for(i = 0; i < 4; i++) {
if(vlc[i].table)
free_vlc(&vlc[i]);
av_free(h[i].bits);
av_free(h[i].lengths);
av_free(h[i].values);
}
*data_size = unp_size;
return buf_size;
}
static AVPictureType parse_picture_type(const uint8_t *buf, int buflen, CVC1HeaderParser *vc1Header)
{
AVPictureType pictype = AV_PICTURE_TYPE_NONE;
int skipped = 0;
const BYTE *framestart = buf;
if (IS_MARKER(AV_RB32(buf))) {
framestart = NULL;
const BYTE *start, *end, *next;
next = buf;
for (start = buf, end = buf + buflen; next < end; start = next) {
if (AV_RB32(start) == VC1_CODE_FRAME) {
framestart = start + 4;
break;
}
next = find_next_marker(start + 4, end);
}
}
if (framestart) {
GetBitContext gb;
init_get_bits(&gb, framestart, (buflen - (framestart-buf))*8);
if (vc1Header->hdr.profile == PROFILE_ADVANCED) {
int fcm = PROGRESSIVE;
if (vc1Header->hdr.interlaced)
fcm = decode012(&gb);
if (fcm == ILACE_FIELD) {
int fptype = get_bits(&gb, 3);
pictype = (fptype & 2) ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
if (fptype & 4) // B-picture
pictype = (fptype & 2) ? AV_PICTURE_TYPE_BI : AV_PICTURE_TYPE_B;
} else {
switch (get_unary(&gb, 0, 4)) {
case 0:
pictype = AV_PICTURE_TYPE_P;
break;
case 1:
pictype = AV_PICTURE_TYPE_B;
break;
case 2:
pictype = AV_PICTURE_TYPE_I;
break;
case 3:
pictype = AV_PICTURE_TYPE_BI;
break;
case 4:
pictype = AV_PICTURE_TYPE_P; // skipped pic
skipped = 1;
break;
}
}
} else {
if (vc1Header->hdr.finterp)
skip_bits1(&gb);
skip_bits(&gb, 2); // framecnt
if (vc1Header->hdr.rangered)
skip_bits1(&gb);
int pic = get_bits1(&gb);
if (vc1Header->hdr.bframes) {
if (!pic) {
if (get_bits1(&gb)) {
pictype = AV_PICTURE_TYPE_I;
} else {
pictype = AV_PICTURE_TYPE_B;
}
} else {
pictype = AV_PICTURE_TYPE_P;
}
} else {
pictype = pic ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
}
}
}
return pictype;
}
void CVC1HeaderParser::VC1ParseSequenceHeader(GetBitContext *gb)
{
hdr.profile = get_bits(gb, 2);
if (hdr.profile == PROFILE_ADVANCED) {
hdr.valid = 1;
hdr.level = get_bits(gb, 3);
skip_bits(gb, 2); // Chroma Format, only 1 should be set for 4:2:0
skip_bits(gb, 3); // frmrtq_postproc
skip_bits(gb, 5); // bitrtq_postproc
skip_bits1(gb); // postprocflag
hdr.width = (get_bits(gb, 12) + 1) << 1;
hdr.height = (get_bits(gb, 12) + 1) << 1;
hdr.broadcast = get_bits1(gb); // broadcast
hdr.interlaced = get_bits1(gb); // interlaced
skip_bits1(gb); // tfcntrflag
skip_bits1(gb); // finterpflag
skip_bits1(gb); // reserved
skip_bits1(gb); // psf
if (get_bits1(gb)) { // Display Info
int w, h, ar = 0;
w = get_bits(gb, 14) + 1;
h = get_bits(gb, 14) + 1;
if (get_bits1(gb))
ar = get_bits(gb, 4);
if (ar && ar < 14) {
hdr.ar = ff_vc1_pixel_aspect[ar];
} else if (ar == 15) {
w = get_bits(gb, 8) + 1;
h = get_bits(gb, 8) + 1;
hdr.ar.num = w;
hdr.ar.den = h;
} else {
av_reduce(&hdr.ar.num, &hdr.ar.den, hdr.height * w, hdr.width * h, 1 << 30);
}
}
// TODO: add other fields
} else {
hdr.valid = 1;
hdr.old_interlaced = get_bits1(gb); // res_y411
skip_bits1(gb); // res_sprite
skip_bits(gb, 3); // frmrtq_postproc
skip_bits(gb, 5); // bitrtq_postproc
skip_bits1(gb); // loop_filter
skip_bits1(gb); // res_x8
skip_bits1(gb); // multires
skip_bits1(gb); // rest_fasttx
skip_bits1(gb); // fastuvmc
skip_bits1(gb); // extended_mv
skip_bits(gb, 2); // dquant
skip_bits1(gb); // vstransform
skip_bits1(gb); // res_transtab
skip_bits1(gb); // overlap
skip_bits1(gb); // resync marker
hdr.rangered = get_bits1(gb);
hdr.bframes = get_bits(gb, 3);
skip_bits(gb, 2); // quant mode
hdr.finterp = get_bits1(gb);
}
}
/**
* read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :)
*/
static void preview_obmc(MpegEncContext *s){
GetBitContext gb= s->gb;
int cbpc, i, pred_x, pred_y, mx, my;
int16_t *mot_val;
const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;
const int stride= s->b8_stride*2;
for(i=0; i<4; i++)
s->block_index[i]+= 2;
for(i=4; i<6; i++)
s->block_index[i]+= 1;
s->mb_x++;
av_assert2(s->pict_type == AV_PICTURE_TYPE_P);
do{
if (get_bits1(&s->gb)) {
/* skip mb */
mot_val = s->current_picture.motion_val[0][s->block_index[0]];
mot_val[0 ]= mot_val[2 ]=
mot_val[0+stride]= mot_val[2+stride]= 0;
mot_val[1 ]= mot_val[3 ]=
mot_val[1+stride]= mot_val[3+stride]= 0;
s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
goto end;
}
cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
}while(cbpc == 20);
if(cbpc & 4){
s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
}else{
get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
if (cbpc & 8) {
if(s->modified_quant){
if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);
else skip_bits(&s->gb, 5);
}else
skip_bits(&s->gb, 2);
}
if ((cbpc & 16) == 0) {
s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
/* 16x16 motion prediction */
mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
if (s->umvplus)
mx = h263p_decode_umotion(s, pred_x);
else
mx = ff_h263_decode_motion(s, pred_x, 1);
if (s->umvplus)
my = h263p_decode_umotion(s, pred_y);
else
my = ff_h263_decode_motion(s, pred_y, 1);
mot_val[0 ]= mot_val[2 ]=
mot_val[0+stride]= mot_val[2+stride]= mx;
mot_val[1 ]= mot_val[3 ]=
mot_val[1+stride]= mot_val[3+stride]= my;
} else {
s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;
for(i=0;i<4;i++) {
mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
if (s->umvplus)
mx = h263p_decode_umotion(s, pred_x);
else
mx = ff_h263_decode_motion(s, pred_x, 1);
if (s->umvplus)
my = h263p_decode_umotion(s, pred_y);
else
my = ff_h263_decode_motion(s, pred_y, 1);
if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
mot_val[0] = mx;
mot_val[1] = my;
}
}
}
end:
for(i=0; i<4; i++)
s->block_index[i]-= 2;
for(i=4; i<6; i++)
s->block_index[i]-= 1;
s->mb_x--;
s->gb= gb;
}
/**
* Store large tree as FFmpeg's vlc codes
*/
static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int **recodes, int *last, int size)
{
int res;
HuffContext huff;
HuffContext tmp1, tmp2;
VLC vlc[2] = { { 0 } };
int escapes[3];
DBCtx ctx;
int err = 0;
if(size >= UINT_MAX>>4){ // (((size + 3) >> 2) + 3) << 2 must not overflow
av_log(smk->avctx, AV_LOG_ERROR, "size too large\n");
return AVERROR_INVALIDDATA;
}
tmp1.length = 256;
tmp1.maxlength = 0;
tmp1.current = 0;
tmp1.bits = av_mallocz(256 * 4);
tmp1.lengths = av_mallocz(256 * sizeof(int));
tmp1.values = av_mallocz(256 * sizeof(int));
tmp2.length = 256;
tmp2.maxlength = 0;
tmp2.current = 0;
tmp2.bits = av_mallocz(256 * 4);
tmp2.lengths = av_mallocz(256 * sizeof(int));
tmp2.values = av_mallocz(256 * sizeof(int));
if (!tmp1.bits || !tmp1.lengths || !tmp1.values ||
!tmp2.bits || !tmp2.lengths || !tmp2.values) {
err = AVERROR(ENOMEM);
goto error;
}
if(get_bits1(gb)) {
res = smacker_decode_tree(gb, &tmp1, 0, 0);
if (res < 0) {
err = res;
goto error;
}
skip_bits1(gb);
if(tmp1.current > 1) {
res = init_vlc(&vlc[0], SMKTREE_BITS, tmp1.length,
tmp1.lengths, sizeof(int), sizeof(int),
tmp1.bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
if(res < 0) {
av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
err = res;
goto error;
}
}
}
if (!vlc[0].table) {
av_log(smk->avctx, AV_LOG_ERROR, "Skipping low bytes tree\n");
}
if(get_bits1(gb)){
res = smacker_decode_tree(gb, &tmp2, 0, 0);
if (res < 0) {
err = res;
goto error;
}
skip_bits1(gb);
if(tmp2.current > 1) {
res = init_vlc(&vlc[1], SMKTREE_BITS, tmp2.length,
tmp2.lengths, sizeof(int), sizeof(int),
tmp2.bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
if(res < 0) {
av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
err = res;
goto error;
}
}
}
if (!vlc[1].table) {
av_log(smk->avctx, AV_LOG_ERROR, "Skipping high bytes tree\n");
}
escapes[0] = get_bits(gb, 16);
escapes[1] = get_bits(gb, 16);
escapes[2] = get_bits(gb, 16);
last[0] = last[1] = last[2] = -1;
ctx.escapes[0] = escapes[0];
ctx.escapes[1] = escapes[1];
ctx.escapes[2] = escapes[2];
ctx.v1 = &vlc[0];
ctx.v2 = &vlc[1];
ctx.recode1 = tmp1.values;
ctx.recode2 = tmp2.values;
ctx.last = last;
huff.length = ((size + 3) >> 2) + 4;
huff.maxlength = 0;
huff.current = 0;
huff.values = av_mallocz_array(huff.length, sizeof(int));
if (!huff.values) {
err = AVERROR(ENOMEM);
goto error;
}
res = smacker_decode_bigtree(gb, &huff, &ctx, 0);
if (res < 0)
err = res;
skip_bits1(gb);
if(ctx.last[0] == -1) ctx.last[0] = huff.current++;
if(ctx.last[1] == -1) ctx.last[1] = huff.current++;
if(ctx.last[2] == -1) ctx.last[2] = huff.current++;
if (ctx.last[0] >= huff.length ||
ctx.last[1] >= huff.length ||
ctx.last[2] >= huff.length) {
av_log(smk->avctx, AV_LOG_ERROR, "Huffman codes out of range\n");
err = AVERROR_INVALIDDATA;
}
*recodes = huff.values;
error:
if(vlc[0].table)
ff_free_vlc(&vlc[0]);
if(vlc[1].table)
ff_free_vlc(&vlc[1]);
av_free(tmp1.bits);
av_free(tmp1.lengths);
av_free(tmp1.values);
av_free(tmp2.bits);
av_free(tmp2.lengths);
av_free(tmp2.values);
return err;
}
/**
* Store large tree as Libav's vlc codes
*/
static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int **recodes, int *last, int size)
{
int res;
HuffContext huff;
HuffContext tmp1, tmp2;
VLC vlc[2] = { { 0 } };
int escapes[3];
DBCtx ctx;
int err = 0;
if(size >= UINT_MAX>>4){ // (((size + 3) >> 2) + 3) << 2 must not overflow
av_log(smk->avctx, AV_LOG_ERROR, "size too large\n");
return -1;
}
tmp1.length = 256;
tmp1.maxlength = 0;
tmp1.current = 0;
tmp1.bits = av_mallocz(256 * 4);
tmp1.lengths = av_mallocz(256 * sizeof(int));
tmp1.values = av_mallocz(256 * sizeof(int));
tmp2.length = 256;
tmp2.maxlength = 0;
tmp2.current = 0;
tmp2.bits = av_mallocz(256 * 4);
tmp2.lengths = av_mallocz(256 * sizeof(int));
tmp2.values = av_mallocz(256 * sizeof(int));
if(get_bits1(gb)) {
smacker_decode_tree(gb, &tmp1, 0, 0);
skip_bits1(gb);
res = init_vlc(&vlc[0], SMKTREE_BITS, tmp1.length,
tmp1.lengths, sizeof(int), sizeof(int),
tmp1.bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
if(res < 0) {
av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
return -1;
}
} else {
av_log(smk->avctx, AV_LOG_ERROR, "Skipping low bytes tree\n");
}
if(get_bits1(gb)){
smacker_decode_tree(gb, &tmp2, 0, 0);
skip_bits1(gb);
res = init_vlc(&vlc[1], SMKTREE_BITS, tmp2.length,
tmp2.lengths, sizeof(int), sizeof(int),
tmp2.bits, sizeof(uint32_t), sizeof(uint32_t), INIT_VLC_LE);
if(res < 0) {
av_log(smk->avctx, AV_LOG_ERROR, "Cannot build VLC table\n");
return -1;
}
} else {
av_log(smk->avctx, AV_LOG_ERROR, "Skipping high bytes tree\n");
}
escapes[0] = get_bits(gb, 8);
escapes[0] |= get_bits(gb, 8) << 8;
escapes[1] = get_bits(gb, 8);
escapes[1] |= get_bits(gb, 8) << 8;
escapes[2] = get_bits(gb, 8);
escapes[2] |= get_bits(gb, 8) << 8;
last[0] = last[1] = last[2] = -1;
ctx.escapes[0] = escapes[0];
ctx.escapes[1] = escapes[1];
ctx.escapes[2] = escapes[2];
ctx.v1 = &vlc[0];
ctx.v2 = &vlc[1];
ctx.recode1 = tmp1.values;
ctx.recode2 = tmp2.values;
ctx.last = last;
huff.length = ((size + 3) >> 2) + 3;
huff.maxlength = 0;
huff.current = 0;
huff.values = av_mallocz(huff.length * sizeof(int));
if (smacker_decode_bigtree(gb, &huff, &ctx) < 0)
err = -1;
skip_bits1(gb);
if(ctx.last[0] == -1) ctx.last[0] = huff.current++;
if(ctx.last[1] == -1) ctx.last[1] = huff.current++;
if(ctx.last[2] == -1) ctx.last[2] = huff.current++;
*recodes = huff.values;
if(vlc[0].table)
ff_free_vlc(&vlc[0]);
if(vlc[1].table)
ff_free_vlc(&vlc[1]);
av_free(tmp1.bits);
av_free(tmp1.lengths);
av_free(tmp1.values);
av_free(tmp2.bits);
av_free(tmp2.lengths);
av_free(tmp2.values);
return err;
}
int ff_h264_decode_ref_pic_marking(const H264Context *h, H264SliceContext *sl,
GetBitContext *gb)
{
int i;
MMCO *mmco = sl->mmco;
int nb_mmco = 0;
if (h->nal_unit_type == NAL_IDR_SLICE) { // FIXME fields
skip_bits1(gb); // broken_link
if (get_bits1(gb)) {
mmco[0].opcode = MMCO_LONG;
mmco[0].long_arg = 0;
nb_mmco = 1;
}
sl->explicit_ref_marking = 1;
} else {
sl->explicit_ref_marking = get_bits1(gb);
if (sl->explicit_ref_marking) {
for (i = 0; i < MAX_MMCO_COUNT; i++) {
MMCOOpcode opcode = get_ue_golomb_31(gb);
mmco[i].opcode = opcode;
if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) {
mmco[i].short_pic_num =
(sl->curr_pic_num - get_ue_golomb_long(gb) - 1) &
(sl->max_pic_num - 1);
#if 0
if (mmco[i].short_pic_num >= h->short_ref_count ||
!h->short_ref[mmco[i].short_pic_num]) {
av_log(s->avctx, AV_LOG_ERROR,
"illegal short ref in memory management control "
"operation %d\n", mmco);
return -1;
}
#endif
}
if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) {
unsigned int long_arg = get_ue_golomb_31(gb);
if (long_arg >= 32 ||
(long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG &&
long_arg == 16) &&
!(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE(h)))) {
av_log(h->avctx, AV_LOG_ERROR,
"illegal long ref in memory management control "
"operation %d\n", opcode);
return -1;
}
mmco[i].long_arg = long_arg;
}
if (opcode > (unsigned) MMCO_LONG) {
av_log(h->avctx, AV_LOG_ERROR,
"illegal memory management control operation %d\n",
opcode);
return -1;
}
if (opcode == MMCO_END)
break;
}
nb_mmco = i;
}
}
sl->nb_mmco = nb_mmco;
return 0;
}
