mirror of
https://github.com/tuxbox-neutrino/libstb-hal.git
synced 2025-08-26 23:13:16 +02:00
679 lines
14 KiB
C
679 lines
14 KiB
C
/*
|
|
* MPEG4 Bitstream/VLC Encoder
|
|
*
|
|
* Copyright (c) 2006 vixy project
|
|
*
|
|
* This file contains the code that based on FFmpeg (http://ffmpeg.mplayerhq.hu/)
|
|
* See original copyright notice in /FFMPEG_CREDITS and /FFMPEG_IMPORTS
|
|
*
|
|
* This file is part of VIXY FLV Converter.
|
|
*
|
|
* 'VIXY FLV Converter' 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.
|
|
*
|
|
* 'VIXY FLV Converter' 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 FFmpeg; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "m4vencode.h"
|
|
#include "m4vencode_tables.h"
|
|
#include "bitwriter.h"
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// same as H.263
|
|
static const uint32 vlce_intra_MCBPC_code[9] = { 1, 1, 2, 3, 1, 1, 2, 3, 1 };
|
|
static const uint32 vlce_intra_MCBPC_bits[9] = { 1, 3, 3, 3, 4, 6, 6, 6, 9 };
|
|
static const uint32 vlce_cbpy_code[16] = { 3, 5, 4, 9, 3, 7, 2, 11, 2, 3, 5, 10, 4, 8, 6, 3};
|
|
static const uint32 vlce_cbpy_bits[16] = { 4, 5, 5, 4, 5, 4, 6, 4, 5, 6, 4, 4, 4, 4, 4, 2};
|
|
|
|
// same as H.263
|
|
static const uint32 vlce_inter_MCBPC_code[28] =
|
|
{
|
|
1, 3, 2, 5,
|
|
3, 4, 3, 3,
|
|
3, 7, 6, 5,
|
|
4, 4, 3, 2,
|
|
2, 5, 4, 5,
|
|
1, 0, 0, 0, /* Stuffing */
|
|
2, 12, 14, 15,
|
|
};
|
|
|
|
// same as H.263
|
|
static const uint32 vlce_inter_MCBPC_bits[28] =
|
|
{
|
|
1, 4, 4, 6, /* inter */
|
|
5, 8, 8, 7, /* intra */
|
|
3, 7, 7, 9, /* interQ */
|
|
6, 9, 9, 9, /* intraQ */
|
|
3, 7, 7, 8, /* inter4 */
|
|
9, 0, 0, 0, /* Stuffing */
|
|
11, 13, 13, 13,/* inter4Q*/
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
static inline void encode_DC(BW *p, int level, int n)
|
|
{
|
|
if (level < -255 || level > 255) printf("dc overflow\n");
|
|
|
|
#if 1
|
|
level += 256;
|
|
if (n < 4)
|
|
{
|
|
put_bits(p, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
|
|
}
|
|
else
|
|
{
|
|
put_bits(p, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
|
|
}
|
|
#else
|
|
|
|
int size, v;
|
|
/* find number of bits */
|
|
size = 0;
|
|
v = abs(level);
|
|
while (v)
|
|
{
|
|
v >>= 1;
|
|
size++;
|
|
}
|
|
|
|
if (n < 4)
|
|
{
|
|
/* luminance */
|
|
put_bits(p, DCtab_lum[size][1], DCtab_lum[size][0]);
|
|
}
|
|
else
|
|
{
|
|
/* chrominance */
|
|
put_bits(p, DCtab_chrom[size][1], DCtab_chrom[size][0]);
|
|
}
|
|
|
|
/* encode remaining bits */
|
|
if (size > 0)
|
|
{
|
|
if (level < 0)
|
|
level = (-level) ^ ((1 << size) - 1);
|
|
put_bits(p, size, level);
|
|
if (size > 8)
|
|
put_bits(p, 1, 1);
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
static inline void encode_escape_3(BW *p, int last, int run, int level)
|
|
{
|
|
#if 0
|
|
put_bits(p,
|
|
7 + 2 + 1 + 6 + 1 + 12 + 1, //30bit
|
|
(3 << 23) + (3 << 21) + (last << 20) + (run << 14) + (1 << 13) + (((level - 64) & 0xfff) << 1) + 1);
|
|
#else
|
|
put_bits(p, 7, 3); // escape
|
|
put_bits(p, 2, 3); // escape3
|
|
put_bits(p, 1, last);
|
|
put_bits(p, 6, run);
|
|
put_bits(p, 1, 1); // marker
|
|
put_bits(p, 12, ((level - 64) & 0xfff));
|
|
put_bits(p, 1, 1); // marker
|
|
#endif
|
|
}
|
|
|
|
#define UNI_MPEG4_ENC_INDEX(last, run, level) ((last)*128*64 + (run)*128 + (level))
|
|
|
|
static inline void 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;
|
|
bits_tab = uni_mpeg4_intra_rl_bits;
|
|
}
|
|
else
|
|
{
|
|
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]];
|
|
if (level)
|
|
{
|
|
int run = i - last_non_zero - 1;
|
|
level += 64;
|
|
if ((level & (~127)) == 0)
|
|
{
|
|
const int index = UNI_MPEG4_ENC_INDEX(0, run, level);
|
|
put_bits(p, len_tab[index], bits_tab[index]);
|
|
}
|
|
else
|
|
{
|
|
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;
|
|
level += 64;
|
|
if ((level & (~127)) == 0)
|
|
{
|
|
const int index = UNI_MPEG4_ENC_INDEX(1, run, level);
|
|
put_bits(p, len_tab[index], bits_tab[index]);
|
|
}
|
|
else
|
|
{
|
|
encode_escape_3(p, 1, run, level);
|
|
}
|
|
}
|
|
#else
|
|
const RL *rl;
|
|
int last, sign, code;
|
|
|
|
if (intra)
|
|
{
|
|
rl = &rl_intra;
|
|
}
|
|
else
|
|
{
|
|
rl = &rl_inter;
|
|
}
|
|
|
|
for (; i <= last_index; i++)
|
|
{
|
|
const int slevel = block->block[scan_table[i]];
|
|
if (slevel)
|
|
{
|
|
int level;
|
|
int run = i - last_non_zero - 1;
|
|
last = (i == last_index);
|
|
sign = 0;
|
|
level = slevel;
|
|
if (level < 0)
|
|
{
|
|
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)
|
|
{
|
|
int level1, run1;
|
|
level1 = level - rl->max_level[run][last];
|
|
if (level1 < 1)
|
|
goto esc2;
|
|
|
|
code = get_rl_index(rl, last, run, level1);
|
|
if (code == rl->n)
|
|
{
|
|
esc2:
|
|
put_bits(p, 1, 1);
|
|
if (level > 64)
|
|
goto esc3;
|
|
run1 = run - rl->max_run[level][last] - 1;
|
|
if (run1 < 0)
|
|
goto esc3;
|
|
code = get_rl_index(rl, last, run1, level);
|
|
if (code == rl->n)
|
|
{
|
|
esc3:
|
|
/* third escape */
|
|
put_bits(p, 1, 1);
|
|
put_bits(p, 1, last);
|
|
put_bits(p, 6, run);
|
|
put_bits(p, 1, 1);
|
|
put_bits(p, 12, slevel & 0xfff);
|
|
put_bits(p, 1, 1);
|
|
}
|
|
else
|
|
{
|
|
/* second escape */
|
|
put_bits(p, 1, 0);
|
|
put_bits(p, rl->table_vlc[code][1], rl->table_vlc[code][0]);
|
|
put_bits(p, 1, sign);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* first escape */
|
|
put_bits(p, 1, 0);
|
|
put_bits(p, rl->table_vlc[code][1], rl->table_vlc[code][0]);
|
|
put_bits(p, 1, sign);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
put_bits(p, 1, sign);
|
|
}
|
|
last_non_zero = i;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
}
|
|
|
|
static inline void encode_intra_block(BW *bw, M4V_BLOCK *block, int n)
|
|
{
|
|
encode_DC(bw, block->block[0], n);
|
|
encode_AC(bw, block, 1);
|
|
}
|
|
|
|
static inline void encode_inter_block(BW *bw, M4V_BLOCK *block)
|
|
{
|
|
encode_AC(bw, block, 0);
|
|
}
|
|
|
|
// same as H.263
|
|
static inline void encode_intra_I_MCBPC(BW *bw, int cbpc)
|
|
{
|
|
put_bits(bw, vlce_intra_MCBPC_bits[cbpc], vlce_intra_MCBPC_code[cbpc]);
|
|
}
|
|
|
|
// same as H.263
|
|
static inline void encode_intra_P_MCBPC(BW *bw, int cbpc)
|
|
{
|
|
put_bits(bw, vlce_inter_MCBPC_bits[cbpc + 4], vlce_inter_MCBPC_code[cbpc + 4]);
|
|
}
|
|
|
|
// same as H.263
|
|
static inline void encode_inter_16x16_MCBPC(BW *bw, int cbpc)
|
|
{
|
|
put_bits(bw, vlce_inter_MCBPC_bits[cbpc], vlce_inter_MCBPC_code[cbpc]);
|
|
}
|
|
|
|
// same as H.263
|
|
static inline void 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 inline void encode_cbpy(BW *bw, int cbpy)
|
|
{
|
|
put_bits(bw, vlce_cbpy_bits[cbpy], vlce_cbpy_code[cbpy]);
|
|
}
|
|
|
|
// same as H.263
|
|
static inline void encode_dquant(BW *bw, int dquant)
|
|
{
|
|
const uint32 dquant_code[5] = {1, 0, -1, 2, 3};
|
|
if (dquant)
|
|
{
|
|
put_bits(bw, 2, dquant_code[dquant + 2]);
|
|
}
|
|
}
|
|
|
|
// same as FLV
|
|
static inline void encode_motion(BW *bw, VLCDEC *mv_x, VLCDEC *mv_y)
|
|
{
|
|
put_vlcdec(bw, mv_x);
|
|
if (mv_x->bits_ex)
|
|
{
|
|
put_bits(bw, 1, mv_x->value_ex & 1);
|
|
if (mv_x->bits_ex > 1)
|
|
{
|
|
put_bits(bw, mv_x->bits_ex - 1, mv_x->value_ex >> 1);
|
|
}
|
|
|
|
}
|
|
put_vlcdec(bw, mv_y);
|
|
if (mv_y->bits_ex)
|
|
{
|
|
put_bits(bw, 1, mv_y->value_ex & 1);
|
|
if (mv_y->bits_ex > 1)
|
|
{
|
|
put_bits(bw, mv_y->bits_ex - 1, mv_y->value_ex >> 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
// same as FLV
|
|
static inline void 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)
|
|
{
|
|
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:
|
|
encode_inter_16x16_MCBPC(bw, cbpc);
|
|
encode_cbpy(bw, cbpy);
|
|
encode_dquant(bw, mb->dquant);
|
|
encode_motion(bw, &mb->mv_x[0], &mb->mv_y[0]);
|
|
break;
|
|
case MV_TYPE_8X8:
|
|
encode_inter_8x8_MCBPC(bw, cbpc);
|
|
encode_cbpy(bw, cbpy);
|
|
encode_dquant(bw, mb->dquant);
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
encode_motion(bw, &mb->mv_x[i], &mb->mv_y[i]);
|
|
}
|
|
break;
|
|
}
|
|
|
|
for (i = 0; i < 6; i++)
|
|
{
|
|
encode_inter_block(bw, &mb->block[i]);
|
|
}
|
|
}
|
|
|
|
static inline void encode_mb_intra_internal(BW *bw, M4V_MICROBLOCK *mb, int iframe)
|
|
{
|
|
int cbp = 0, cbpc, cbpy;
|
|
int i;
|
|
|
|
for (i = 0; i < 6; i++)
|
|
{
|
|
if (mb->block[i].last_index >= 1)
|
|
{
|
|
cbp |= 1 << (5 - i);
|
|
}
|
|
}
|
|
|
|
cbpc = cbp & 3;
|
|
if (iframe)
|
|
{
|
|
if (mb->dquant) cbpc += 4;
|
|
encode_intra_I_MCBPC(bw, cbpc);
|
|
}
|
|
else
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
static inline int 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;
|
|
}
|
|
|
|
static inline int 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
|
|
put_bits(p, 13, vol->width); // width
|
|
put_bits(p, 1, 1); // marker
|
|
put_bits(p, 13, vol->height); // height
|
|
put_bits(p, 1, 1); // marker
|
|
put_bits(p, 1, 0); // progressive = false
|
|
put_bits(p, 1, 1); // obmc disable = true
|
|
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;
|
|
}
|
|
|
|
static inline int 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);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
static inline int 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');
|
|
put_bits(p, 8, 'y');
|
|
put_bits(p, 8, '.');
|
|
put_bits(p, 8, 'n');
|
|
put_bits(p, 8, 'e');
|
|
put_bits(p, 8, 't');
|
|
|
|
m4v_stuffing(p);
|
|
return 0;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
void m4v_encode_m4v_header(BW *bw, M4V_VOL *vol, uint32 time)
|
|
{
|
|
encode_vo_header(bw);
|
|
encode_vol_header(bw, vol);
|
|
// encode_gop_header(bw, time);
|
|
encode_user_header(bw);
|
|
}
|
|
|
|
void m4v_encode_vop_header(BW *bw, M4V_VOP *vop, int time_bits, int vop_not_coded)
|
|
{
|
|
encode_vop_header(bw, vop, time_bits, vop_not_coded);
|
|
}
|
|
|
|
void m4v_encode_I_mb(BW *bw, M4V_MICROBLOCK *mb)
|
|
{
|
|
encode_mb_intra_internal(bw, mb, 1);
|
|
}
|
|
|
|
// same as FLV
|
|
void m4v_encode_P_mb(BW *bw, M4V_MICROBLOCK *mb)
|
|
{
|
|
if (mb->skip)
|
|
{
|
|
put_bits(bw, 1, 1); // not coded
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
put_bits(bw, 1, 0); // coded
|
|
}
|
|
|
|
if (mb->intra)
|
|
{
|
|
encode_mb_intra_internal(bw, mb, 0);
|
|
}
|
|
else
|
|
{
|
|
encode_mb_inter_internal(bw, mb);
|
|
}
|
|
}
|
|
|
|
int m4v_encode_I_dcpred(M4V_MICROBLOCK *mb, M4V_DCPRED *dcpred, int mb_x, int mb_y)
|
|
{
|
|
int n;
|
|
if (mb->intra)
|
|
{
|
|
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]);
|
|
mb->block[n].block[0] = level;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|