diff options
Diffstat (limited to 'media/libstagefright/codecs/m4v_h263/enc/src/vlc_encode.cpp')
| -rw-r--r-- | media/libstagefright/codecs/m4v_h263/enc/src/vlc_encode.cpp | 2799 |
1 files changed, 2799 insertions, 0 deletions
diff --git a/media/libstagefright/codecs/m4v_h263/enc/src/vlc_encode.cpp b/media/libstagefright/codecs/m4v_h263/enc/src/vlc_encode.cpp new file mode 100644 index 0000000..7ea5dc4 --- /dev/null +++ b/media/libstagefright/codecs/m4v_h263/enc/src/vlc_encode.cpp @@ -0,0 +1,2799 @@ +/* ------------------------------------------------------------------ + * Copyright (C) 1998-2009 PacketVideo + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either + * express or implied. + * See the License for the specific language governing permissions + * and limitations under the License. + * ------------------------------------------------------------------- + */ +/****************************************************************************** +* +* This software module was originally developed by +* +* Robert Danielsen (Telenor / ACTS-MoMuSys). +* +* and edited by +* +* Luis Ducla-Soares (IST / ACTS-MoMuSys). +* Cor Quist (KPN / ACTS-MoMuSys). +* +* in the course of development of the MPEG-4 Video (ISO/IEC 14496-2) standard. +* This software module is an implementation of a part of one or more MPEG-4 +* Video (ISO/IEC 14496-2) tools as specified by the MPEG-4 Video (ISO/IEC +* 14496-2) standard. +* +* ISO/IEC gives users of the MPEG-4 Video (ISO/IEC 14496-2) standard free +* license to this software module or modifications thereof for use in hardware +* or software products claiming conformance to the MPEG-4 Video (ISO/IEC +* 14496-2) standard. +* +* Those intending to use this software module in hardware or software products +* are advised that its use may infringe existing patents. The original +* developer of this software module and his/her company, the subsequent +* editors and their companies, and ISO/IEC have no liability for use of this +* software module or modifications thereof in an implementation. Copyright is +* not released for non MPEG-4 Video (ISO/IEC 14496-2) standard conforming +* products. +* +* ACTS-MoMuSys partners retain full right to use the code for his/her own +* purpose, assign or donate the code to a third party and to inhibit third +* parties from using the code for non MPEG-4 Video (ISO/IEC 14496-2) standard +* conforming products. This copyright notice must be included in all copies or +* derivative works. +* +* Copyright (c) 1997 +* +*****************************************************************************/ + +/***********************************************************HeaderBegin******* +* +* File: putvlc.c +* +* Author: Robert Danielsen, Telenor R&D +* Created: 07.07.96 +* +* Description: Functions for writing to bitstream +* +* Notes: Same kind of tables as in the MPEG-2 software simulation +* group software. +* +* Modified: +* 28.10.96 Robert Danielsen: Added PutCoeff_Intra(), renamed +* PutCoeff() to PutCoeff_Inter(). +* 06.11.96 Robert Danielsen: Added PutMCBPC_sep() +* 01.05.97 Luis Ducla-Soares: added PutCoeff_Intra_RVLC() and +* PutCoeff_Inter_RVLC(). +* +***********************************************************HeaderEnd*********/ + +/************************ INCLUDE FILES ********************************/ + + +#include "mp4lib_int.h" +#include "mp4enc_lib.h" +#include "vlc_enc_tab.h" +#include "bitstream_io.h" +#include "m4venc_oscl.h" +#include "vlc_encode_inline.h" + +typedef void (*BlockCodeCoeffPtr)(RunLevelBlock*, BitstreamEncVideo*, Int, Int, UChar) ; + +const static Int mode_MBtype[] = +{ + 3, + 0, + 4, + 1, + 2, +}; + +const static Int zigzag_inv[NCOEFF_BLOCK] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63 +}; + +/* Horizontal zigzag inverse */ +const static Int zigzag_h_inv[NCOEFF_BLOCK] = +{ + 0, 1, 2, 3, 8, 9, 16, 17, + 10, 11, 4, 5, 6, 7, 15, 14, + 13, 12, 19, 18, 24, 25, 32, 33, + 26, 27, 20, 21, 22, 23, 28, 29, + 30, 31, 34, 35, 40, 41, 48, 49, + 42, 43, 36, 37, 38, 39, 44, 45, + 46, 47, 50, 51, 56, 57, 58, 59, + 52, 53, 54, 55, 60, 61, 62, 63 +}; + +/* Vertical zigzag inverse */ +const static Int zigzag_v_inv[NCOEFF_BLOCK] = +{ + 0, 8, 16, 24, 1, 9, 2, 10, + 17, 25, 32, 40, 48, 56, 57, 49, + 41, 33, 26, 18, 3, 11, 4, 12, + 19, 27, 34, 42, 50, 58, 35, 43, + 51, 59, 20, 28, 5, 13, 6, 14, + 21, 29, 36, 44, 52, 60, 37, 45, + 53, 61, 22, 30, 7, 15, 23, 31, + 38, 46, 54, 62, 39, 47, 55, 63 +}; + +#ifdef __cplusplus +extern "C" +{ +#endif + + Int PutCoeff_Inter(Int run, Int level, BitstreamEncVideo *bitstream); + Int PutCoeff_Inter_Last(Int run, Int level, BitstreamEncVideo *bitstream); + Int PutCoeff_Intra(Int run, Int level, BitstreamEncVideo *bitstream); + Int PutCoeff_Intra_Last(Int run, Int level, BitstreamEncVideo *bitstream); + Int PutCBPY(Int cbpy, Char intra, BitstreamEncVideo *bitstream); + Int PutMCBPC_Inter(Int cbpc, Int mode, BitstreamEncVideo *bitstream); + Int PutMCBPC_Intra(Int cbpc, Int mode, BitstreamEncVideo *bitstream); + Int PutMV(Int mvint, BitstreamEncVideo *bitstream); + Int PutDCsize_chrom(Int size, BitstreamEncVideo *bitstream); + Int PutDCsize_lum(Int size, BitstreamEncVideo *bitstream); + Int PutDCsize_lum(Int size, BitstreamEncVideo *bitstream); +#ifndef NO_RVLC + Int PutCoeff_Inter_RVLC(Int run, Int level, BitstreamEncVideo *bitstream); + Int PutCoeff_Inter_RVLC_Last(Int run, Int level, BitstreamEncVideo *bitstream); + Int PutCoeff_Intra_RVLC(Int run, Int level, BitstreamEncVideo *bitstream); + Int PutCoeff_Intra_RVLC_Last(Int run, Int level, BitstreamEncVideo *bitstream); +#endif + Int PutRunCoeff_Inter(Int run, Int level, BitstreamEncVideo *bitstream); + Int PutRunCoeff_Inter_Last(Int run, Int level, BitstreamEncVideo *bitstream); + Int PutRunCoeff_Intra(Int run, Int level, BitstreamEncVideo *bitstream); + Int PutRunCoeff_Intra_Last(Int run, Int level, BitstreamEncVideo *bitstream); + Int PutLevelCoeff_Inter(Int run, Int level, BitstreamEncVideo *bitstream); + Int PutLevelCoeff_Inter_Last(Int run, Int level, BitstreamEncVideo *bitstream); + Int PutLevelCoeff_Intra(Int run, Int level, BitstreamEncVideo *bitstream); + Int PutLevelCoeff_Intra_Last(Int run, Int level, BitstreamEncVideo *bitstream); + + void RunLevel(VideoEncData *video, Int intra, Int intraDC_decision, Int ncoefblck[]); + Int IntraDC_dpcm(Int val, Int lum, BitstreamEncVideo *bitstream); + Void DCACPred(VideoEncData *video, UChar Mode, Int *intraDC_decision, Int intraDCVlcQP); + Void find_pmvs(VideoEncData *video, Int block, Int *mvx, Int *mvy); + Void WriteMVcomponent(Int f_code, Int dmv, BitstreamEncVideo *bs); + static Bool IntraDCSwitch_Decision(Int Mode, Int intra_dc_vlc_threshold, Int intraDCVlcQP); + + Void ScaleMVD(Int f_code, Int diff_vector, Int *residual, Int *vlc_code_mag); + +#ifdef __cplusplus +} +#endif + +Int +PutDCsize_lum(Int size, BitstreamEncVideo *bitstream) +{ + Int length; + + if (!(size >= 0 && size < 13)) + return -1; + + length = DCtab_lum[size].len; + if (length) + BitstreamPutBits(bitstream, length, DCtab_lum[size].code); + + return length; +} + +Int +PutDCsize_chrom(Int size, BitstreamEncVideo *bitstream) +{ + Int length; + + if (!(size >= 0 && size < 13)) + return -1; + length = DCtab_chrom[size].len; + if (length) + BitstreamPutBits(bitstream, length, DCtab_chrom[size].code); + + return length; +} + +Int +PutMV(Int mvint, BitstreamEncVideo *bitstream) +{ + Int sign = 0; + Int absmv; + Int length; + + if (mvint > 32) + { + absmv = -mvint + 65; + sign = 1; + } + else + absmv = mvint; + + length = mvtab[absmv].len; + if (length) + BitstreamPutBits(bitstream, length, mvtab[absmv].code); + + if (mvint != 0) + { + BitstreamPut1Bits(bitstream, sign); + return (length + 1); + } + else + return length; +} + +Int +PutMCBPC_Intra(Int cbp, Int mode, BitstreamEncVideo *bitstream) +{ + Int ind; + Int length; + + ind = ((mode_MBtype[mode] >> 1) & 3) | ((cbp & 3) << 2); + + length = mcbpc_intra_tab[ind].len; + if (length) + BitstreamPutBits(bitstream, length, mcbpc_intra_tab[ind].code); + + return length; +} + +Int +PutMCBPC_Inter(Int cbp, Int mode, BitstreamEncVideo *bitstream) +{ + Int ind; + Int length; + + ind = (mode_MBtype[mode] & 7) | ((cbp & 3) << 3); + + length = mcbpc_inter_tab[ind].len; + if (length) + BitstreamPutBits(bitstream, length, mcbpc_inter_tab[ind].code); + + return length; +} + +Int +PutCBPY(Int cbpy, Char intra, BitstreamEncVideo *bitstream) +{ + Int ind; + Int length; + + if ((intra == 0)) + cbpy = 15 - cbpy; + + ind = cbpy; + + length = cbpy_tab[ind].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)cbpy_tab[ind].code); + + return length; +} + +/* 5/16/01, break up function for last and not-last coefficient */ +/* Note:::: I checked the ARM assembly for if( run > x && run < y) type + of code, they do a really good job compiling it to if( (UInt)(run-x) < y-x). + No need to hand-code it!!!!!, 6/1/2001 */ + +Int PutCoeff_Inter(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run < 2 && level < 13) + { + length = coeff_tab0[run][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_tab0[run][level-1].code); + } + else if (run > 1 && run < 27 && level < 5) + { + length = coeff_tab1[run-2][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_tab1[run-2][level-1].code); + } + + return length; +} + +Int PutCoeff_Inter_Last(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run < 2 && level < 4) + { + length = coeff_tab2[run][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_tab2[run][level-1].code); + } + else if (run > 1 && run < 42 && level == 1) + { + length = coeff_tab3[run-2].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_tab3[run-2].code); + } + + return length; +} + +/* 5/16/01, break up function for last and not-last coefficient */ + +Int PutCoeff_Intra(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run == 0 && level < 28) + { + length = coeff_tab4[level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_tab4[level-1].code); + } + else if (run == 1 && level < 11) + { + length = coeff_tab5[level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_tab5[level-1].code); + } + else if (run > 1 && run < 10 && level < 6) + { + length = coeff_tab6[run-2][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_tab6[run-2][level-1].code); + } + else if (run > 9 && run < 15 && level == 1) + { + length = coeff_tab7[run-10].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_tab7[run-10].code); + } + + return length; +} + +Int PutCoeff_Intra_Last(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run == 0 && level < 9) + { + length = coeff_tab8[level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_tab8[level-1].code); + } + else if (run > 0 && run < 7 && level < 4) + { + length = coeff_tab9[run-1][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_tab9[run-1][level-1].code); + } + else if (run > 6 && run < 21 && level == 1) + { + length = coeff_tab10[run-7].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_tab10[run-7].code); + } + + return length; +} + +/* 5/16/01, break up function for last and not-last coefficient */ +#ifndef NO_RVLC +Int PutCoeff_Inter_RVLC(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run == 0 && level < 20) + { + length = coeff_RVLCtab14[level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab14[level-1].code); + } + else if (run == 1 && level < 11) + { + length = coeff_RVLCtab15[level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab15[level-1].code); + } + else if (run > 1 && run < 4 && level < 8) + { + length = coeff_RVLCtab16[run-2][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab16[run-2][level-1].code); + } + else if (run == 4 && level < 6) + { + length = coeff_RVLCtab17[level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab17[level-1].code); + } + else if (run > 4 && run < 8 && level < 5) + { + length = coeff_RVLCtab18[run-5][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab18[run-5][level-1].code); + } + else if (run > 7 && run < 10 && level < 4) + { + length = coeff_RVLCtab19[run-8][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab19[run-8][level-1].code); + } + else if (run > 9 && run < 18 && level < 3) + { + length = coeff_RVLCtab20[run-10][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab20[run-10][level-1].code); + } + else if (run > 17 && run < 39 && level == 1) + { + length = coeff_RVLCtab21[run-18].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab21[run-18].code); + } + + return length; +} + +Int PutCoeff_Inter_RVLC_Last(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run >= 0 && run < 2 && level < 6) + { + length = coeff_RVLCtab22[run][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab22[run][level-1].code); + } + else if (run == 2 && level < 4) + { + length = coeff_RVLCtab23[level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab23[level-1].code); + } + else if (run > 2 && run < 14 && level < 3) + { + length = coeff_RVLCtab24[run-3][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab24[run-3][level-1].code); + } + else if (run > 13 && run < 45 && level == 1) + { + length = coeff_RVLCtab25[run-14].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab25[run-14].code); + } + + return length; +} + +/* 5/16/01, break up function for last and not-last coefficient */ + +Int PutCoeff_Intra_RVLC(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run == 0 && level < 28) + { + length = coeff_RVLCtab1[level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab1[level-1].code); + } + else if (run == 1 && level < 14) + { + length = coeff_RVLCtab2[level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab2[level-1].code); + } + else if (run == 2 && level < 12) + { + length = coeff_RVLCtab3[level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab3[level-1].code); + } + else if (run == 3 && level < 10) + { + length = coeff_RVLCtab4[level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab4[level-1].code); + } + else if (run > 3 && run < 6 && level < 7) + { + length = coeff_RVLCtab5[run-4][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab5[run-4][level-1].code); + } + else if (run > 5 && run < 8 && level < 6) + { + length = coeff_RVLCtab6[run-6][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab6[run-6][level-1].code); + } + else if (run > 7 && run < 10 && level < 5) + { + length = coeff_RVLCtab7[run-8][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab7[run-8][level-1].code); + + } + else if (run > 9 && run < 13 && level < 3) + { + length = coeff_RVLCtab8[run-10][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab8[run-10][level-1].code); + } + else if (run > 12 && run < 20 && level == 1) + { + length = coeff_RVLCtab9[run-13].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab9[run-13].code); + } + return length; +} + +Int PutCoeff_Intra_RVLC_Last(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run >= 0 && run < 2 && level < 6) + { + length = coeff_RVLCtab10[run][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab10[run][level-1].code); + } + else if (run == 2 && level < 4) + { + length = coeff_RVLCtab11[level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab11[level-1].code); + } + else if (run > 2 && run < 14 && level < 3) + { + length = coeff_RVLCtab12[run-3][level-1].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab12[run-3][level-1].code); + } + else if (run > 13 && run < 45 && level == 1) + { + length = coeff_RVLCtab13[run-14].len; + if (length) + BitstreamPutBits(bitstream, length, (UInt)coeff_RVLCtab13[run-14].code); + } + return length; +} +#endif + +/* The following is for 3-mode VLC */ + +Int +PutRunCoeff_Inter(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run < 2 && level < 13) + { + length = coeff_tab0[run][level-1].len; + if (length) + { + BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/); + //BitstreamPutBits(bitstream, 2, 2); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab0[run][level-1].code); + length += 9; + } + } + else if (run > 1 && run < 27 && level < 5) + { + length = coeff_tab1[run-2][level-1].len; + if (length) + { + BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/); + //BitstreamPutBits(bitstream, 2, 2); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab1[run-2][level-1].code); + length += 9; + } + } + return length; +} + +Int PutRunCoeff_Inter_Last(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run < 2 && level < 4) + { + length = coeff_tab2[run][level-1].len; + if (length) + { + BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/); + //BitstreamPutBits(bitstream, 2, 2); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab2[run][level-1].code); + length += 9; + } + } + else if (run > 1 && run < 42 && level == 1) + { + length = coeff_tab3[run-2].len; + if (length) + { + BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/); + //BitstreamPutBits(bitstream, 2, 2); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab3[run-2].code); + length += 9; + } + } + return length; +} + +Int PutRunCoeff_Intra(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run == 0 && level < 28) + { + length = coeff_tab4[level-1].len; + if (length) + { + BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/); + //BitstreamPutBits(bitstream, 2, 2); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab4[level-1].code); + length += 9; + } + } + else if (run == 1 && level < 11) + { + length = coeff_tab5[level-1].len; + if (length) + { + BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/); + //BitstreamPutBits(bitstream, 2, 2); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab5[level-1].code); + length += 9; + } + } + else if (run > 1 && run < 10 && level < 6) + { + length = coeff_tab6[run-2][level-1].len; + if (length) + { + BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/); + //BitstreamPutBits(bitstream, 2, 2); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab6[run-2][level-1].code); + length += 9; + } + } + else if (run > 9 && run < 15 && level == 1) + { + length = coeff_tab7[run-10].len; + if (length) + { + BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/); + //BitstreamPutBits(bitstream, 2, 2); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab7[run-10].code); + length += 9; + } + } + return length; +} +Int PutRunCoeff_Intra_Last(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run == 0 && level < 9) + { + length = coeff_tab8[level-1].len; + if (length) + { + BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/); + //BitstreamPutBits(bitstream, 2, 2); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab8[level-1].code); + length += 9; + } + } + else if (run > 0 && run < 7 && level < 4) + { + length = coeff_tab9[run-1][level-1].len; + if (length) + { + BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/); + //BitstreamPutBits(bitstream, 2, 2); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab9[run-1][level-1].code); + length += 9; + } + } + else if (run > 6 && run < 21 && level == 1) + { + length = coeff_tab10[run-7].len; + if (length) + { + BitstreamPutGT8Bits(bitstream, 7 + 2, 14/*3*/); + //BitstreamPutBits(bitstream, 2, 2); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab10[run-7].code); + length += 9; + } + } + return length; +} + +Int +PutLevelCoeff_Inter(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run < 2 && level < 13) + { + length = coeff_tab0[run][level-1].len; + if (length) + { + BitstreamPutBits(bitstream, 7 + 1, 6/*3*/); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab0[run][level-1].code); + length += 8; + } + } + else if (run > 1 && run < 27 && level < 5) + { + length = coeff_tab1[run-2][level-1].len; + if (length) + { + BitstreamPutBits(bitstream, 7 + 1, 6/*3*/); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab1[run-2][level-1].code); + length += 8; + } + } + return length; +} + +Int PutLevelCoeff_Inter_Last(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run < 2 && level < 4) + { + length = coeff_tab2[run][level-1].len; + if (length) + { + BitstreamPutBits(bitstream, 7 + 1, 6/*3*/); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab2[run][level-1].code); + length += 8; + } + } + else if (run > 1 && run < 42 && level == 1) + { + length = coeff_tab3[run-2].len; + if (length) + { + BitstreamPutBits(bitstream, 7 + 1, 6/*3*/); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab3[run-2].code); + length += 8; + } + } + return length; +} + +Int PutLevelCoeff_Intra(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run == 0 && level < 28) + { + length = coeff_tab4[level-1].len; + if (length) + { + BitstreamPutBits(bitstream, 7 + 1, 6/*3*/); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab4[level-1].code); + length += 8; + } + } + else if (run == 1 && level < 11) + { + length = coeff_tab5[level-1].len; + if (length) + { + BitstreamPutBits(bitstream, 7 + 1, 6/*3*/); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab5[level-1].code); + length += 8; + } + } + else if (run > 1 && run < 10 && level < 6) + { + length = coeff_tab6[run-2][level-1].len; + if (length) + { + BitstreamPutBits(bitstream, 7 + 1, 6/*3*/); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab6[run-2][level-1].code); + length += 8; + } + } + else if (run > 9 && run < 15 && level == 1) + { + length = coeff_tab7[run-10].len; + if (length) + { + BitstreamPutBits(bitstream, 7 + 1, 6/*3*/); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab7[run-10].code); + length += 8; + } + } + return length; +} +Int PutLevelCoeff_Intra_Last(Int run, Int level, BitstreamEncVideo *bitstream) +{ + Int length = 0; + + if (run == 0 && level < 9) + { + length = coeff_tab8[level-1].len; + if (length) + { + BitstreamPutBits(bitstream, 7 + 1, 6/*3*/); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab8[level-1].code); + length += 8; + } + } + else if (run > 0 && run < 7 && level < 4) + { + length = coeff_tab9[run-1][level-1].len; + if (length) + { + BitstreamPutBits(bitstream, 7 + 1, 6/*3*/); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab9[run-1][level-1].code); + length += 8; + } + } + else if (run > 6 && run < 21 && level == 1) + { + length = coeff_tab10[run-7].len; + if (length) + { + BitstreamPutBits(bitstream, 7 + 1, 6/*3*/); + BitstreamPutBits(bitstream, length, (UInt)coeff_tab10[run-7].code); + length += 8; + } + } + return length; +} + + + +/* ======================================================================== */ +/* Function : MBVlcEncode() */ +/* Date : 09/10/2000 */ +/* Purpose : Encode GOV Header */ +/* In/out : */ +/* Return : */ +/* Modified : 5/21/01, break up into smaller functions */ +/* ======================================================================== */ +#ifndef H263_ONLY +/**************************************/ +/* Data Partitioning I-VOP Encoding */ +/**************************************/ + +void MBVlcEncodeDataPar_I_VOP( + VideoEncData *video, + Int ncoefblck[], + void *blkCodePtr) +{ + + BitstreamEncVideo *bs1 = video->bitstream1; + BitstreamEncVideo *bs2 = video->bitstream2; + BitstreamEncVideo *bs3 = video->bitstream3; + int i; + UChar Mode = video->headerInfo.Mode[video->mbnum]; + UChar CBP; +// MacroBlock *MB=video->outputMB; + Int mbnum = video->mbnum; + Int intraDC_decision, DC; +// int temp; + Int dquant; /* 3/15/01 */ + RunLevelBlock *RLB = video->RLB; + BlockCodeCoeffPtr BlockCodeCoeff = (BlockCodeCoeffPtr) blkCodePtr; + + /* DC and AC Prediction, 5/28/01, compute CBP, intraDC_decision*/ + DCACPred(video, Mode, &intraDC_decision, video->QP_prev); + + /* CBP, Run, Level, and Sign */ + RunLevel(video, 1, intraDC_decision, ncoefblck); + CBP = video->headerInfo.CBP[mbnum]; + + /* Compute DQuant */ + dquant = video->QPMB[mbnum] - video->QP_prev; /* 3/15/01, QP_prev may not equal QPMB[mbnum-1] if mbnum-1 is skipped*/ + + video->QP_prev = video->QPMB[mbnum]; + + if (dquant && Mode == MODE_INTRA) + { + Mode = MODE_INTRA_Q; + } + + if (dquant >= 0) + dquant = (PV_ABS(dquant) + 1); + else + dquant = (PV_ABS(dquant) - 1); + + /* FIRST PART: ALL TO BS1 */ + + PutMCBPC_Intra(CBP, Mode, bs1); /* MCBPC */ + + if (Mode == MODE_INTRA_Q) + /* MAY NEED TO CHANGE DQUANT HERE */ + BitstreamPutBits(bs1, 2, dquant); /* dquant*/ + + + if (intraDC_decision == 0) + { + for (i = 0; i < 6; i++) + { + DC = video->RLB[i].level[0]; + if (video->RLB[i].s[0]) + DC = -DC; + if (i < 4) + /*temp =*/ IntraDC_dpcm(DC, 1, bs1); /* dct_dc_size_luminance, */ + else /* dct_dc_differential, and */ + /*temp =*/ IntraDC_dpcm(DC, 0, bs1); /* marker bit */ + } + } + + /* SECOND PART: ALL TO BS2*/ + + BitstreamPut1Bits(bs2, video->acPredFlag[video->mbnum]); /* ac_pred_flag */ + + /*temp=*/ + PutCBPY(CBP >> 2, (Char)(1), bs2); /* cbpy */ + + + /* THIRD PART: ALL TO BS3*/ + /* MB_CodeCoeff(video,bs3); */ /* 5/22/01, replaced with below */ + for (i = 0; i < 6; i++) + { + if (CBP&(1 << (5 - i))) + (*BlockCodeCoeff)(&(RLB[i]), bs3, 1 - intraDC_decision, ncoefblck[i], Mode);/* Code Intra AC*/ + } + + return ; +} + +/************************************/ +/* Data Partitioning P-VOP Encoding */ +/************************************/ + +void MBVlcEncodeDataPar_P_VOP( + VideoEncData *video, + Int ncoefblck[], + void *blkCodePtr) +{ + + BitstreamEncVideo *bs1 = video->bitstream1; + BitstreamEncVideo *bs2 = video->bitstream2; + BitstreamEncVideo *bs3 = video->bitstream3; + int i; + Int mbnum = video->mbnum; + UChar Mode = video->headerInfo.Mode[mbnum]; + Int QP_tmp = video->QPMB[mbnum]; + UChar CBP; +// MacroBlock *MB=video->outputMB; + Int intra, intraDC_decision, DC; + Int pmvx, pmvy; +// int temp; + Int dquant; /* 3/15/01 */ + RunLevelBlock *RLB = video->RLB; + BlockCodeCoeffPtr BlockCodeCoeff = (BlockCodeCoeffPtr) blkCodePtr; + + intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q); + + /* DC and AC Prediction, 5/28/01, compute CBP, intraDC_decision*/ + + if (intra) + { + if (video->usePrevQP) + { + QP_tmp = video->QPMB[mbnum-1]; + } + + DCACPred(video, Mode, &intraDC_decision, QP_tmp); + } + else + intraDC_decision = 0; /* used in RunLevel */ + + /* CBP, Run, Level, and Sign */ + RunLevel(video, intra, intraDC_decision, ncoefblck); + CBP = video->headerInfo.CBP[mbnum]; + + /* Compute DQuant */ + dquant = video->QPMB[mbnum] - video->QP_prev; /* 3/15/01, QP_prev may not equal QPMB[mbnum-1] if mbnum-1 is skipped*/ + + if (dquant && (Mode == MODE_INTRA || Mode == MODE_INTER)) + { + Mode += 2; /* make it MODE_INTRA_Q and MODE_INTER_Q */ + } + + if (dquant >= 0) + dquant = (PV_ABS(dquant) + 1); + else + dquant = (PV_ABS(dquant) - 1); + + /* FIRST PART: ALL TO BS1 */ + + if (CBP == 0 && intra == 0) /* Determine if Skipped MB */ + { + if ((Mode == MODE_INTER) && (video->mot[mbnum][0].x == 0) && (video->mot[mbnum][0].y == 0)) + Mode = video->headerInfo.Mode[video->mbnum] = MODE_SKIPPED; + else if ((Mode == MODE_INTER4V) && (video->mot[mbnum][1].x == 0) && (video->mot[mbnum][1].y == 0) + && (video->mot[mbnum][2].x == 0) && (video->mot[mbnum][2].y == 0) + && (video->mot[mbnum][3].x == 0) && (video->mot[mbnum][3].y == 0) + && (video->mot[mbnum][4].x == 0) && (video->mot[mbnum][4].y == 0)) + Mode = video->headerInfo.Mode[video->mbnum] = MODE_SKIPPED; + } + + + if (Mode == MODE_SKIPPED) + { + BitstreamPut1Bits(bs1, 1); /* not_coded = 1 */ + return; + } + else + BitstreamPut1Bits(bs1, 0); /* not_coded =0 */ + + video->QP_prev = video->QPMB[mbnum]; + video->usePrevQP = 1; + + PutMCBPC_Inter(CBP, Mode, bs1); /* MCBPC */ + + video->header_bits -= BitstreamGetPos(bs1); /* Header Bits */ + + if (Mode == MODE_INTER || Mode == MODE_INTER_Q) + { + find_pmvs(video, 0, &pmvx, &pmvy); /* Get predicted motion vectors */ + WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][0].x - pmvx, bs1); /* Write x to bitstream */ + WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][0].y - pmvy, bs1); /* Write y to bitstream */ + } + else if (Mode == MODE_INTER4V) + { + for (i = 1; i < 5; i++) + { + find_pmvs(video, i, &pmvx, &pmvy); + WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][i].x - pmvx, bs1); + WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][i].y - pmvy, bs1); + } + } + video->header_bits += BitstreamGetPos(bs1); /* Header Bits */ + + /* SECOND PART: ALL TO BS2 */ + + + if (intra) + { + BitstreamPut1Bits(bs2, video->acPredFlag[video->mbnum]); /* ac_pred_flag */ + /*temp=*/ + PutCBPY(CBP >> 2, (Char)(Mode == MODE_INTRA || Mode == MODE_INTRA_Q), bs2); /* cbpy */ + + if (Mode == MODE_INTRA_Q) + BitstreamPutBits(bs2, 2, dquant); /* dquant, 3/15/01*/ + + if (intraDC_decision == 0) + { + for (i = 0; i < 6; i++) + { + DC = video->RLB[i].level[0]; + if (video->RLB[i].s[0]) + DC = -DC; + if (i < 4) + /*temp =*/ IntraDC_dpcm(DC, 1, bs2); /* dct_dc_size_luminance, */ + else /* dct_dc_differential, and */ + /*temp =*/ IntraDC_dpcm(DC, 0, bs2); /* marker bit */ + } + } + + /****************************/ /* THIRD PART: ALL TO BS3 */ + for (i = 0; i < 6; i++) + { + if (CBP&(1 << (5 - i))) + (*BlockCodeCoeff)(&(RLB[i]), bs3, 1 - intraDC_decision, ncoefblck[i], Mode);/* Code Intra AC*/ + } + } + else + { + /*temp=*/ + PutCBPY(CBP >> 2, (Char)(Mode == MODE_INTRA || Mode == MODE_INTRA_Q), bs2); /* cbpy */ + if (Mode == MODE_INTER_Q) + /* MAY NEED TO CHANGE DQUANT HERE */ + BitstreamPutBits(bs2, 2, dquant); /* dquant, 3/15/01*/ + + /****************************/ /* THIRD PART: ALL TO BS3 */ + for (i = 0; i < 6; i++) + { + if (CBP&(1 << (5 - i))) + (*BlockCodeCoeff)(&(RLB[i]), bs3, 0, ncoefblck[i], Mode);/* Code Intra AC*/ + } + } + + return ; +} +#endif /* H263_ONLY */ +/****************************************************************************************/ +/* Short Header/Combined Mode with or without Error Resilience I-VOP and P-VOP Encoding */ +/* 5/21/01, B-VOP is not implemented yet!!!! */ +/****************************************************************************************/ + +void MBVlcEncodeCombined_I_VOP( + VideoEncData *video, + Int ncoefblck[], + void *blkCodePtr) +{ + + BitstreamEncVideo *bs1 = video->bitstream1; +// BitstreamEncVideo *bs2 = video->bitstream2; +// BitstreamEncVideo *bs3 = video->bitstream3; + int i; + UChar Mode = video->headerInfo.Mode[video->mbnum]; + UChar CBP = video->headerInfo.CBP[video->mbnum]; +// MacroBlock *MB=video->outputMB; + Int mbnum = video->mbnum; + Int intraDC_decision; +// int temp; + Int dquant; /* 3/15/01 */ + RunLevelBlock *RLB = video->RLB; + Int DC; + Int shortVideoHeader = video->vol[video->currLayer]->shortVideoHeader; + BlockCodeCoeffPtr BlockCodeCoeff = (BlockCodeCoeffPtr) blkCodePtr; + + /* DC and AC Prediction, 5/28/01, compute CBP, intraDC_decision*/ + +#ifndef H263_ONLY + if (!shortVideoHeader) + DCACPred(video, Mode, &intraDC_decision, video->QP_prev); + else +#endif + { + intraDC_decision = 0; + } + + /* CBP, Run, Level, and Sign */ + + RunLevel(video, 1, intraDC_decision, ncoefblck); + CBP = video->headerInfo.CBP[mbnum]; + + /* Compute DQuant */ + dquant = video->QPMB[mbnum] - video->QP_prev; /* 3/15/01, QP_prev may not equal QPMB[mbnum-1] if mbnum-1 is skipped*/ + + video->QP_prev = video->QPMB[mbnum]; + + if (dquant && Mode == MODE_INTRA) + { + Mode = MODE_INTRA_Q; + } + + if (dquant >= 0) + dquant = (PV_ABS(dquant) + 1); + else + dquant = (PV_ABS(dquant) - 1); + + PutMCBPC_Intra(CBP, Mode, bs1); /* mcbpc I_VOP */ + + if (!video->vol[video->currLayer]->shortVideoHeader) + { + BitstreamPut1Bits(bs1, video->acPredFlag[video->mbnum]); /* ac_pred_flag */ + } + + /*temp=*/ + PutCBPY(CBP >> 2, (Char)(1), bs1); /* cbpy */ + + if (Mode == MODE_INTRA_Q) + /* MAY NEED TO CHANGE DQUANT HERE */ + BitstreamPutBits(bs1, 2, dquant); /* dquant, 3/15/01*/ + + /*MB_CodeCoeff(video,bs1); 5/21/01, replaced by below */ + /*******************/ +#ifndef H263_ONLY + if (shortVideoHeader) /* Short Header DC coefficients */ + { +#endif + for (i = 0; i < 6; i++) + { + DC = RLB[i].level[0]; + if (RLB[i].s[0]) + DC = -DC; + if (DC != 128) + BitstreamPutBits(bs1, 8, DC); /* intra_dc_size_luminance */ + else + BitstreamPutBits(bs1, 8, 255); /* intra_dc_size_luminance */ + if (CBP&(1 << (5 - i))) + (*BlockCodeCoeff)(&(RLB[i]), bs1, 1, ncoefblck[i], Mode); /* Code short header Intra AC*/ + } +#ifndef H263_ONLY + } + else if (intraDC_decision == 0) /* Combined Intra Mode DC and AC coefficients */ + { + for (i = 0; i < 6; i++) + { + DC = RLB[i].level[0]; + if (RLB[i].s[0]) + DC = -DC; + + if (i < 4) + /*temp =*/ IntraDC_dpcm(DC, 1, bs1); /* dct_dc_size_luminance, */ + else /* dct_dc_differential, and */ + /*temp =*/ IntraDC_dpcm(DC, 0, bs1); /* marker bit */ + if (CBP&(1 << (5 - i))) + (*BlockCodeCoeff)(&(RLB[i]), bs1, 1, ncoefblck[i], Mode);/* Code Intra AC */ + } + } + else /* Combined Mode Intra DC/AC coefficients */ + { + for (i = 0; i < 6; i++) + { + if (CBP&(1 << (5 - i))) + (*BlockCodeCoeff)(&(RLB[i]), bs1, 0, ncoefblck[i], Mode);/* Code Intra AC */ + } + } +#endif + /*******************/ + return ; +} + +void MBVlcEncodeCombined_P_VOP( + VideoEncData *video, + Int ncoefblck[], + void *blkCodePtr) +{ + + BitstreamEncVideo *bs1 = video->bitstream1; +// BitstreamEncVideo *bs2 = video->bitstream2; +// BitstreamEncVideo *bs3 = video->bitstream3; + int i; + Int mbnum = video->mbnum; + UChar Mode = video->headerInfo.Mode[mbnum]; + Int QP_tmp = video->QPMB[mbnum]; + UChar CBP ; +// MacroBlock *MB=video->outputMB; + Int intra, intraDC_decision; + Int pmvx, pmvy; +// int temp; + Int dquant; /* 3/15/01 */ + RunLevelBlock *RLB = video->RLB; + Int DC; + Int shortVideoHeader = video->vol[video->currLayer]->shortVideoHeader; + BlockCodeCoeffPtr BlockCodeCoeff = (BlockCodeCoeffPtr) blkCodePtr; + + intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q); + + /* DC and AC Prediction, 5/28/01, compute intraDC_decision*/ +#ifndef H263_ONLY + if (!shortVideoHeader && intra) + { + if (video->usePrevQP) + { + QP_tmp = video->QPMB[mbnum-1]; + } + DCACPred(video, Mode, &intraDC_decision, QP_tmp); + } + else +#endif + intraDC_decision = 0; + + /* CBP, Run, Level, and Sign */ + + RunLevel(video, intra, intraDC_decision, ncoefblck); + CBP = video->headerInfo.CBP[mbnum]; + + /* Compute DQuant */ + dquant = video->QPMB[mbnum] - video->QP_prev; /* 3/15/01, QP_prev may not equal QPMB[mbnum-1] if mbnum-1 is skipped*/ + if (dquant && (Mode == MODE_INTRA || Mode == MODE_INTER)) + { + Mode += 2; /* make it MODE_INTRA_Q and MODE_INTER_Q */ + } + + if (dquant >= 0) + dquant = (PV_ABS(dquant) + 1); + else + dquant = (PV_ABS(dquant) - 1); + + if (CBP == 0 && intra == 0) /* Determine if Skipped MB */ + { + if ((Mode == MODE_INTER) && (video->mot[mbnum][0].x == 0) && (video->mot[mbnum][0].y == 0)) + Mode = video->headerInfo.Mode[video->mbnum] = MODE_SKIPPED; + else if ((Mode == MODE_INTER4V) && (video->mot[mbnum][1].x == 0) && (video->mot[mbnum][1].y == 0) + && (video->mot[mbnum][2].x == 0) && (video->mot[mbnum][2].y == 0) + && (video->mot[mbnum][3].x == 0) && (video->mot[mbnum][3].y == 0) + && (video->mot[mbnum][4].x == 0) && (video->mot[mbnum][4].y == 0)) + Mode = video->headerInfo.Mode[video->mbnum] = MODE_SKIPPED; + } + + if (Mode == MODE_SKIPPED) + { + BitstreamPut1Bits(bs1, 1); /* not_coded = 1 */ + return; + } + else + BitstreamPut1Bits(bs1, 0); /* not_coded =0 */ + + video->QP_prev = video->QPMB[mbnum]; + video->usePrevQP = 1; + + PutMCBPC_Inter(CBP, Mode, bs1); /* mcbpc P_VOP */ + + if (!video->vol[video->currLayer]->shortVideoHeader && intra) + { + BitstreamPut1Bits(bs1, video->acPredFlag[video->mbnum]); /* ac_pred_flag */ + } + + /*temp=*/ + PutCBPY(CBP >> 2, (Char)(intra), bs1); /* cbpy */ + + if (Mode == MODE_INTRA_Q || Mode == MODE_INTER_Q) + /* MAY NEED TO CHANGE DQUANT HERE */ + BitstreamPutBits(bs1, 2, dquant); /* dquant, 3/15/01*/ + + video->header_bits -= BitstreamGetPos(bs1); /* Header Bits */ + + if (!((video->vol[video->currLayer]->scalability) && (video->currVop->refSelectCode == 3))) + { + if (Mode == MODE_INTER || Mode == MODE_INTER_Q) + { + find_pmvs(video, 0, &pmvx, &pmvy); /* Get predicted motion vectors */ + WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][0].x - pmvx, bs1); /* Write x to bitstream */ + WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][0].y - pmvy, bs1); /* Write y to bitstream */ + } + else if (Mode == MODE_INTER4V) + { + for (i = 1; i < 5; i++) + { + find_pmvs(video, i, &pmvx, &pmvy); + WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][i].x - pmvx, bs1); + WriteMVcomponent(video->currVop->fcodeForward, video->mot[mbnum][i].y - pmvy, bs1); + } + } + } + video->header_bits += BitstreamGetPos(bs1); /* Header Bits */ + + /* MB_CodeCoeff(video,bs1); */ /* 5/22/01, replaced with below */ + /****************************/ + if (intra) + { +#ifndef H263_ONLY + if (shortVideoHeader) /* Short Header DC coefficients */ + { +#endif + for (i = 0; i < 6; i++) + { + DC = RLB[i].level[0]; + if (RLB[i].s[0]) + DC = -DC; + if (DC != 128) + BitstreamPutBits(bs1, 8, DC); /* intra_dc_size_luminance */ + else + BitstreamPutBits(bs1, 8, 255); /* intra_dc_size_luminance */ + if (CBP&(1 << (5 - i))) + (*BlockCodeCoeff)(&(RLB[i]), bs1, 1, ncoefblck[i], Mode); /* Code short header Intra AC*/ + } +#ifndef H263_ONLY + } + else if (intraDC_decision == 0) /* Combined Intra Mode DC and AC coefficients */ + { + for (i = 0; i < 6; i++) + { + DC = RLB[i].level[0]; + if (RLB[i].s[0]) + DC = -DC; + + if (i < 4) + /*temp =*/ IntraDC_dpcm(DC, 1, bs1); /* dct_dc_size_luminance, */ + else /* dct_dc_differential, and */ + /*temp =*/ IntraDC_dpcm(DC, 0, bs1); /* marker bit */ + if (CBP&(1 << (5 - i))) + (*BlockCodeCoeff)(&(RLB[i]), bs1, 1, ncoefblck[i], Mode);/* Code Intra AC */ + } + } + else /* Combined Mode Intra DC/AC coefficients */ + { + for (i = 0; i < 6; i++) + { + if (CBP&(1 << (5 - i))) + (*BlockCodeCoeff)(&(RLB[i]), bs1, 0, ncoefblck[i], Mode);/* Code Intra AC */ + } + } +#endif + } + else /* Shortheader or Combined INTER Mode AC coefficients */ + { + for (i = 0; i < 6; i++) + { + if (CBP&(1 << (5 - i))) + (*BlockCodeCoeff)(&(RLB[i]), bs1, 0, ncoefblck[i], Mode);/* Code Inter AC*/ + } + } + /****************************/ + + return ; +} + +/* ======================================================================== */ +/* Function : BlockCodeCoeff() */ +/* Date : 09/18/2000 */ +/* Purpose : VLC Encode AC/DC coeffs */ +/* In/out : */ +/* Return : */ +/* Modified : 5/16/01 grouping BitstreamPutBits calls */ +/* 5/22/01 break up function */ +/* ======================================================================== */ +#ifndef NO_RVLC +/*****************/ +/* RVLC ENCODING */ +/*****************/ +Void BlockCodeCoeff_RVLC(RunLevelBlock *RLB, BitstreamEncVideo *bs, Int j_start, Int j_stop, UChar Mode) +{ + int length = 0; + int i; + Int level; + Int run; + Int intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q); + + /* Not Last Coefficient */ + for (i = j_start; i < j_stop - 1; i++) + { + run = RLB->run[i]; + level = RLB->level[i]; + //if(i==63||RLB->run[i+1] == -1) /* Don't Code Last Coefficient Here */ + // break; + /*ENCODE RUN LENGTH */ + if (level < 28 && run < 39) + { + if (intra) + length = PutCoeff_Intra_RVLC(run, level, bs); + else + length = PutCoeff_Inter_RVLC(run, level, bs); + } + else + length = 0; + /* ESCAPE CODING */ + if (length == 0) + { + BitstreamPutBits(bs, 5 + 1, 2); /* ESCAPE + Not Last Coefficient */ + //BitstreamPutBits(bs,1,0); /* Not Last Coefficient */ + BitstreamPutBits(bs, 6 + 1, (run << 1) | 1); /* RUN + MARKER BIT*/ + //BitstreamPutBits(bs,1,1); /* MARKER BIT */ + BitstreamPutGT8Bits(bs, 11, level); /* LEVEL */ + BitstreamPutBits(bs, 1 + 4, 16); /* MARKER BIT */ + //BitstreamPutBits(bs,4,0); /* RVLC TRAILING ESCAPE */ + } + BitstreamPutBits(bs, 1, RLB->s[i]); /* SIGN BIT */ + } + /* Last Coefficient!!! */ + run = RLB->run[i]; + level = RLB->level[i]; + + /*ENCODE RUN LENGTH */ + if (level < 6 && run < 45) + { + if (intra) + length = PutCoeff_Intra_RVLC_Last(run, level, bs); + else + length = PutCoeff_Inter_RVLC_Last(run, level, bs); + } + else + length = 0; + /* ESCAPE CODING */ + if (length == 0) + { + BitstreamPutBits(bs, 5 + 1, 3); /* ESCAPE CODE + Last Coefficient*/ + //BitstreamPutBits(bs,1,1); /* Last Coefficient !*/ + BitstreamPutBits(bs, 6 + 1, (run << 1) | 1); /* RUN + MARKER BIT*/ + //BitstreamPutBits(bs,1,1); /* MARKER BIT */ + BitstreamPutGT8Bits(bs, 11, level); /* LEVEL */ + BitstreamPutBits(bs, 1 + 4, 16); /* MARKER BIT + RVLC TRAILING ESCAPE */ + //BitstreamPutBits(bs,4,0); /* */ + } + BitstreamPut1Bits(bs, RLB->s[i]); /* SIGN BIT */ + + return ; +} +#endif +/*******************************/ +/* SHORT VIDEO HEADER ENCODING */ +/*******************************/ + +Void BlockCodeCoeff_ShortHeader(RunLevelBlock *RLB, BitstreamEncVideo *bs, Int j_start, Int j_stop, UChar Mode) +{ + int length = 0; + int i; +// int temp; + Int level; + Int run; + + OSCL_UNUSED_ARG(Mode); + + /* Not Last Coefficient */ + for (i = j_start; i < j_stop - 1; i++) + { + run = RLB->run[i]; + level = RLB->level[i]; +// if(i==63 ||RLB->run[i+1] == -1) /* Don't Code Last Coefficient Here */ +// break; + /*ENCODE RUN LENGTH */ + if (level < 13) + { + length = PutCoeff_Inter(run, level, bs); + if (length != 0) + /*temp =*/ BitstreamPut1Bits(bs, RLB->s[i]); /* Sign Bit */ + } + else + length = 0; + /* ESCAPE CODING */ + if (length == 0) + { + if (RLB->s[i]) + level = -level; + BitstreamPutBits(bs, 7 + 1, 6); /* ESCAPE CODE + Not Last Coefficient */ + //BitstreamPutBits(bs,1,0); /* Not Last Coefficient */ + BitstreamPutBits(bs, 6, run); /* RUN */ + BitstreamPutBits(bs, 8, level&0xFF); /* LEVEL, mask to make sure length 8 */ + } + } + /* Last Coefficient!!! */ + run = RLB->run[i]; + level = RLB->level[i]; + + /*ENCODE RUN LENGTH */ + if (level < 13) + { + length = PutCoeff_Inter_Last(run, level, bs); + if (length != 0) + /*temp =*/ BitstreamPut1Bits(bs, RLB->s[i]); /* Sign Bit */ + } + else + length = 0; + /* ESCAPE CODING */ + if (length == 0) + { + if (RLB->s[i]) + level = -level; + BitstreamPutBits(bs, 7 + 1, 7); /* ESCAPE CODE + Last Coefficient */ + //BitstreamPutBits(bs,1,1); /* Last Coefficient !!!*/ + BitstreamPutBits(bs, 6, run); /* RUN */ + BitstreamPutBits(bs, 8, level&0xFF); /* LEVEL, mask to make sure length 8 */ + } + + return ; + +} + +#ifndef H263_ONLY +/****************/ +/* VLC ENCODING */ +/****************/ +Void BlockCodeCoeff_Normal(RunLevelBlock *RLB, BitstreamEncVideo *bs, Int j_start, Int j_stop, UChar Mode) +{ + int length = 0; + int i; + //int temp; + Int level; + Int run; + Int intra = (Mode == MODE_INTRA || Mode == MODE_INTRA_Q); + Int level_minus_max; + Int run_minus_max; + Int(*PutCoeff)(Int, Int, BitstreamEncVideo *); /* pointer to functions, 5/28/01 */ + + /* Not Last Coefficient!!! */ + + if (intra) + PutCoeff = &PutCoeff_Intra; + else + PutCoeff = &PutCoeff_Inter; + + for (i = j_start; i < j_stop - 1; i++) + { + run = RLB->run[i]; + level = RLB->level[i]; + + /* Encode Run Length */ + if (level < 28) + { + length = (*PutCoeff)(run, level, bs); /* 5/28/01 replaces above */ + } + else + { + length = 0; + } + + /* First escape mode: LEVEL OFFSET */ + if (length == 0) + { + if (intra) + { + level_minus_max = level - intra_max_level[0][run]; + if (level_minus_max < 28) + length = PutLevelCoeff_Intra(run, level_minus_max, bs); + else + length = 0; + } + else + { + level_minus_max = level - inter_max_level[0][run]; + if (level_minus_max < 13) + length = PutLevelCoeff_Inter(run, level_minus_max, bs); + else + length = 0; + } + + /* Second escape mode: RUN OFFSET */ + if (length == 0) + { + if (level < 28) + { + if (intra) + { + run_minus_max = run - (intra_max_run0[level] + 1); + length = PutRunCoeff_Intra(run_minus_max, level, bs); + } + else if (level < 13) + { + run_minus_max = run - (inter_max_run0[level] + 1); + length = PutRunCoeff_Inter(run_minus_max, level, bs); + } + else + { + length = 0; + } + } + else + { + length = 0; + } + + /* Third escape mode: FIXED LENGTH CODE */ + if (length == 0) + { + if (RLB->s[i]) + level = -level; + /*temp =*/ + BitstreamPutBits(bs, 7 + 2 + 1, 30); /* ESCAPE CODE + Followed by 11 + Not Last Coefficient*/ + //temp = BitstreamPutBits(bs,2,3); /* Followed by 11 */ + //temp = BitstreamPutBits(bs, 1, 0); /* Not Last Coefficient*/ + /*temp =*/ + BitstreamPutBits(bs, 6 + 1, (run << 1) | 1); /* Encode Run + Marker Bit */ + //temp = BitstreamPutBits(bs,1,1); /* Marker Bit */ + /*temp =*/ + BitstreamPutGT8Bits(bs, 12 + 1, ((level << 1) | 1)&0x1FFF); /* Encode Level, mask to make sure length 12 */ + //temp = BitstreamPutBits(bs,1,1); /* Marker Bit */ + } + } + } + + /* Encode Sign Bit */ + if (length != 0) + /*temp =*/ BitstreamPut1Bits(bs, RLB->s[i]); /* Sign Bit */ + + } + /* Last Coefficient */ + run = RLB->run[i]; + level = RLB->level[i]; + + /* Encode Run Length */ + if (level < 9) + { + if (intra) + { + length = PutCoeff_Intra_Last(run, level, bs); + } + else if (level < 4) + { + length = PutCoeff_Inter_Last(run, level, bs); + } + else + { + length = 0; + } + } + else + { + length = 0; + } + + /* First escape mode: LEVEL OFFSET */ + if (length == 0) + { + if (intra) + { + level_minus_max = level - intra_max_level[1][run]; + if (level_minus_max < 9) + length = PutLevelCoeff_Intra_Last(run, level_minus_max, bs); + else + length = 0; + } + else + { + level_minus_max = level - inter_max_level[1][run]; + if (level_minus_max < 4) + length = PutLevelCoeff_Inter_Last(run, level_minus_max, bs); + else + length = 0; + } + /* Second escape mode: RUN OFFSET */ + if (length == 0) + { + if (level < 9) + { + if (intra) + { + run_minus_max = run - (intra_max_run1[level] + 1); + length = PutRunCoeff_Intra_Last(run_minus_max, level, bs); + } + else if (level < 4) + { + run_minus_max = run - (inter_max_run1[level] + 1); + length = PutRunCoeff_Inter_Last(run_minus_max, level, bs); + } + else + { + length = 0; + } + } + else + { + length = 0; + } + /* Third escape mode: FIXED LENGTH CODE */ + if (length == 0) + { + if (RLB->s[i]) + level = -level; + /*temp =*/ + BitstreamPutGT8Bits(bs, 7 + 2 + 1, 31); /* ESCAPE CODE + Followed by 11 + Last Coefficient*/ + //temp = BitstreamPutBits(bs,2,3); /* Followed by 11 */ + //temp = BitstreamPutBits(bs, 1, 1); /* Last Coefficient!!!*/ + /*temp =*/ + BitstreamPutBits(bs, 6 + 1, (run << 1) | 1); /* Encode Run + Marker Bit */ + //temp = BitstreamPutBits(bs,1,1); /* Marker Bit */ + /*temp =*/ + BitstreamPutGT8Bits(bs, 12 + 1, ((level << 1) | 1)&0x1FFF); /* Encode Level, mask to make sure length 8 */ + //temp = BitstreamPutBits(bs,1,1); /* Marker Bit */ + } + } + } + + /* Encode Sign Bit */ + if (length != 0) + /*temp =*/ BitstreamPut1Bits(bs, RLB->s[i]); + + + return ; +} + +#endif /* H263_ONLY */ +/* ======================================================================== */ +/* Function : RUNLevel */ +/* Date : 09/20/2000 */ +/* Purpose : Get the Coded Block Pattern for each block */ +/* In/out : */ +/* Int* qcoeff Quantized DCT coefficients + Int Mode Coding Mode + Int ncoeffs Number of coefficients */ +/* Return : */ +/* Int CBP Coded Block Pattern */ +/* Modified : */ +/* ======================================================================== */ + +void RunLevel(VideoEncData *video, Int intra, Int intraDC_decision, Int ncoefblck[]) +{ + Int i, j; + Int CBP = video->headerInfo.CBP[video->mbnum]; + Int ShortNacNintra = (!(video->vol[video->currLayer]->shortVideoHeader) && video->acPredFlag[video->mbnum] && intra); + MacroBlock *MB = video->outputMB; + Short *dataBlock; + Int level; + RunLevelBlock *RLB; + Int run, idx; + Int *zz, nc, zzorder; + UChar imask[6] = {0x1F, 0x2F, 0x37, 0x3B, 0x3D, 0x3E}; + UInt *bitmapzz; + + /* Set Run, Level and CBP for this Macroblock */ + /* ZZ scan is done here. */ + + if (intra) + { + + if (intraDC_decision != 0) + intra = 0; /* DC/AC in Run/Level */ + + for (i = 0; i < 6 ; i++) + { + + zz = (Int *) zigzag_inv; + + RLB = video->RLB + i; + + dataBlock = MB->block[i]; + + if (intra) + { + RLB->run[0] = 0; + level = dataBlock[0]; + dataBlock[0] = 0; /* reset to zero */ + if (level < 0) + { + RLB->level[0] = -level; + RLB->s[0] = 1; + } + else + { + RLB->level[0] = level; + RLB->s[0] = 0; + } + } + + idx = intra; + + if ((CBP >> (5 - i)) & 1) + { + if (ShortNacNintra) + { + switch ((video->zz_direction >> (5 - i))&1) + { + case 0: + zz = (Int *)zigzag_v_inv; + break; + case 1: + zz = (Int *)zigzag_h_inv; + break; + } + } + run = 0; + nc = ncoefblck[i]; + for (j = intra, zz += intra; j < nc; j++, zz++) + { + zzorder = *zz; + level = dataBlock[zzorder]; + if (level == 0) + run++; + else + { + dataBlock[zzorder] = 0; /* reset output */ + if (level < 0) + { + RLB->level[idx] = -level; + RLB->s[idx] = 1; + RLB->run[idx] = run; + run = 0; + idx++; + } + else + { + RLB->level[idx] = level; + RLB->s[idx] = 0; + RLB->run[idx] = run; + run = 0; + idx++; + } + } + } + } + + ncoefblck[i] = idx; /* 5/22/01, reuse ncoefblck */ + + if (idx == intra) /* reset CBP, nothing to be coded */ + CBP &= imask[i]; + } + + video->headerInfo.CBP[video->mbnum] = CBP; + + return ; + } + else + { +// zz = (Int *) zigzag_inv; no need to use it, default + + if (CBP) + { + for (i = 0; i < 6 ; i++) + { + RLB = video->RLB + i; + idx = 0; + + if ((CBP >> (5 - i)) & 1) + { /* 7/30/01 */ + /* Use bitmapzz to find the Run,Level,Sign symbols */ + bitmapzz = video->bitmapzz[i]; + dataBlock = MB->block[i]; + nc = ncoefblck[i]; + + idx = zero_run_search(bitmapzz, dataBlock, RLB, nc); + } + ncoefblck[i] = idx; /* 5/22/01, reuse ncoefblck */ + if (idx == 0) /* reset CBP, nothing to be coded */ + CBP &= imask[i]; + } + video->headerInfo.CBP[video->mbnum] = CBP; + } + return ; + } +} + +#ifndef H263_ONLY +#ifdef __cplusplus +extern "C" +{ +#endif + static Bool IntraDCSwitch_Decision(Int Mode, Int intra_dc_vlc_thr, Int intraDCVlcQP) + { + Bool switched = FALSE; + + if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) + { + if (intra_dc_vlc_thr != 0) + { + switched = (intra_dc_vlc_thr == 7 || intraDCVlcQP >= intra_dc_vlc_thr * 2 + 11); + } + } + + return switched; + } +#ifdef __cplusplus +} +#endif + +Int IntraDC_dpcm(Int val, Int lum, BitstreamEncVideo *bitstream) +{ + Int n_bits; + Int absval, size = 0; + + absval = (val < 0) ? -val : val; /* abs(val) */ + + + /* compute dct_dc_size */ + + size = 0; + while (absval) + { + absval >>= 1; + size++; + } + + if (lum) + { /* luminance */ + n_bits = PutDCsize_lum(size, bitstream); + } + else + { /* chrominance */ + n_bits = PutDCsize_chrom(size, bitstream); + } + + if (size != 0) + { + if (val >= 0) + { + ; + } + else + { + absval = -val; /* set to "-val" MW 14-NOV-1996 */ + val = absval ^((1 << size) - 1); + } + BitstreamPutBits(bitstream, (size), (UInt)(val)); + n_bits += size; + + if (size > 8) + BitstreamPut1Bits(bitstream, 1); + } + + return n_bits; /* # bits for intra_dc dpcm */ + +} + +/* ======================================================================== */ +/* Function : DC_AC_PRED */ +/* Date : 09/24/2000 */ +/* Purpose : DC and AC encoding of Intra Blocks */ +/* In/out : */ +/* VideoEncData *video + UChar Mode */ +/* Return : */ +/* */ +/* ======================================================================== */ +Int cal_dc_scalerENC(Int QP, Int type) ; + + +#define PREDICT_AC for (m = 0; m < 7; m++){ \ + tmp = DCAC[0]*QPtmp;\ + if(tmp<0) tmp = (tmp-(QP/2))/QP;\ + else tmp = (tmp+(QP/2))/QP;\ + pred[m] = tmp;\ + DCAC++;\ + } + + +Void DCACPred(VideoEncData *video, UChar Mode, Int *intraDC_decision, Int intraDCVlcQP) +{ + MacroBlock *MB = video->outputMB; + Int mbnum = video->mbnum; + typeDCStore *DC_store = video->predDC + mbnum; + typeDCACStore *DCAC_row = video->predDCAC_row; + typeDCACStore *DCAC_col = video->predDCAC_col; + Short *DCAC; + UChar Mode_top, Mode_left; + + Vol *currVol = video->vol[video->currLayer]; + Int nMBPerRow = currVol->nMBPerRow; + Int x_pos = video->outputMB->mb_x; /* 5/28/01 */ + Int y_pos = video->outputMB->mb_y; + UChar QP = video->QPMB[mbnum]; + UChar *QPMB = video->QPMB; + UChar *slice_nb = video->sliceNo; + Bool bACPredEnable = video->encParams->ACDCPrediction; + Int *ACpred_flag = video->acPredFlag; + Int mid_grey = 128 << 3; + Int m; + Int comp; + Int dc_scale = 8, tmp; + + static const Int Xpos[6] = { -1, 0, -1, 0, -1, -1}; + static const Int Ypos[6] = { -1, -1, 0, 0, -1, -1}; + static const Int Xtab[6] = {1, 0, 3, 2, 4, 5}; + static const Int Ytab[6] = {2, 3, 0, 1, 4, 5}; + static const Int Ztab[6] = {3, 2, 1, 0, 4, 5}; + + /* I added these to speed up comparisons */ + static const Int Pos0[6] = { 1, 1, 0, 0, 1, 1}; + static const Int Pos1[6] = { 1, 0, 1, 0, 1, 1}; + static const Int B_Xtab[6] = {0, 1, 0, 1, 2, 3}; + static const Int B_Ytab[6] = {0, 0, 1, 1, 2, 3}; + + Int direction[6]; /* 0: HORIZONTAL, 1: VERTICAL */ + Int block_A, block_B, block_C; + Int grad_hor, grad_ver, DC_pred; + Short pred[7], *predptr; + Short pcoeff[42]; + Short *qcoeff; + Int S = 0, S1, S2; + Int diff, QPtmp; + Int newCBP[6]; + UChar mask1[6] = {0x20, 0x10, 0x8, 0x4, 0x2, 0x1}; +// UChar mask2[6] = {0x1f,0x2f,0x37,0x3b,0x3d,0x3e}; + + Int y_offset, x_offset, x_tab, y_tab, z_tab; /* speedup coefficients */ + Int b_xtab, b_ytab; + + video->zz_direction = 0; + + /* Standard MPEG-4 Headers do DC/AC prediction*/ + /* check whether neighbors are INTER */ + if (y_pos > 0) + { + Mode_top = video->headerInfo.Mode[mbnum-nMBPerRow]; + if (!(Mode_top == MODE_INTRA || Mode_top == MODE_INTRA_Q)) + { + DCAC = DC_store[-nMBPerRow]; + *DCAC++ = mid_grey; + *DCAC++ = mid_grey; + *DCAC++ = mid_grey; + *DCAC++ = mid_grey; + *DCAC++ = mid_grey; + *DCAC++ = mid_grey; + /* set to 0 DCAC_row[x_pos][0..3] */ + if (bACPredEnable == TRUE) + { + M4VENC_MEMSET(DCAC_row[x_pos][0], 0, sizeof(Short) << 5); + } + } + } + if (x_pos > 0) + { + Mode_left = video->headerInfo.Mode[mbnum-1]; + if (!(Mode_left == MODE_INTRA || Mode_left == MODE_INTRA_Q)) + { + DCAC = DC_store[-1]; + *DCAC++ = mid_grey; + *DCAC++ = mid_grey; + *DCAC++ = mid_grey; + *DCAC++ = mid_grey; + *DCAC++ = mid_grey; + *DCAC++ = mid_grey; + /* set to 0 DCAC_col[x_pos][0..3] */ + if (bACPredEnable == TRUE) + { + M4VENC_MEMSET(DCAC_col[0][0], 0, sizeof(Short) << 5); + } + } + } + + S1 = 0; + S2 = 0; + + for (comp = 0; comp < 6; comp++) + { + + if (Ypos[comp] != 0) y_offset = -nMBPerRow; + else y_offset = 0; + x_offset = Xpos[comp]; + x_tab = Xtab[comp]; + y_tab = Ytab[comp]; + z_tab = Ztab[comp]; + + b_xtab = B_Xtab[comp]; + b_ytab = B_Ytab[comp]; + + qcoeff = MB->block[comp]; + + /****************************/ + /* Store DC coefficients */ + /****************************/ + /* Store coeff values for Intra MB */ + if (comp == 0) dc_scale = cal_dc_scalerENC(QP, 1) ; + if (comp == 4) dc_scale = cal_dc_scalerENC(QP, 2) ; + + QPtmp = qcoeff[0] * dc_scale; /* DC value */ + + if (QPtmp > 2047) /* 10/10/01, add clipping (bug fixed) */ + DC_store[0][comp] = 2047; + else if (QPtmp < -2048) + DC_store[0][comp] = -2048; + else + DC_store[0][comp] = QPtmp; + + /**************************************************************/ + /* Find the direction of the prediction and the DC prediction */ + /**************************************************************/ + + if ((x_pos == 0) && y_pos == 0) + { /* top left corner */ + block_A = (comp == 1 || comp == 3) ? DC_store[0][x_tab] : mid_grey; + block_B = (comp == 3) ? DC_store[x_offset][z_tab] : mid_grey; + block_C = (comp == 2 || comp == 3) ? DC_store[0][y_tab] : mid_grey; + } + else if (x_pos == 0) + { /* left edge */ + block_A = (comp == 1 || comp == 3) ? DC_store[0][x_tab] : mid_grey; + block_B = ((comp == 1 && (slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow])) || comp == 3) ? + DC_store[y_offset+x_offset][z_tab] : mid_grey; + block_C = (comp == 2 || comp == 3 || + (Pos0[comp] && (slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow]))) ? + DC_store[y_offset][y_tab] : mid_grey; + } + else if (y_pos == 0) + { /* top row */ + block_A = (comp == 1 || comp == 3 || (Pos1[comp] && (slice_nb[mbnum] == slice_nb[mbnum-1]))) ? + DC_store[x_offset][x_tab] : mid_grey; + block_B = ((comp == 2 && (slice_nb[mbnum] == slice_nb[mbnum-1])) || comp == 3) ? + DC_store[y_offset + x_offset][z_tab] : mid_grey; + block_C = (comp == 2 || comp == 3) ? + DC_store[y_offset][y_tab] : mid_grey; + } + else + { + block_A = (comp == 1 || comp == 3 || (Pos1[comp] && (slice_nb[mbnum] == slice_nb[mbnum-1]))) ? + DC_store[x_offset][x_tab] : mid_grey; + block_B = (((comp == 0 || comp == 4 || comp == 5) && + (slice_nb[mbnum] == slice_nb[mbnum-1-nMBPerRow])) || + (comp == 1 && (slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow])) || + (comp == 2 && (slice_nb[mbnum] == slice_nb[mbnum-1])) || (comp == 3)) ? + (DC_store[y_offset + x_offset][z_tab]) : mid_grey; + block_C = (comp == 2 || comp == 3 || (Pos0[comp] && (slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow]))) ? + DC_store[y_offset][y_tab] : mid_grey; + } + grad_hor = block_B - block_C; + grad_ver = block_A - block_B; + + if ((PV_ABS(grad_ver)) < (PV_ABS(grad_hor))) + { + DC_pred = block_C; + direction[comp] = 1; + video->zz_direction = (video->zz_direction) | mask1[comp]; + + } + else + { + DC_pred = block_A; + direction[comp] = 0; + //video->zz_direction=video->zz_direction<<1; + } + + /* DC prediction */ + QPtmp = dc_scale; /* 5/28/01 */ + qcoeff[0] -= (DC_pred + QPtmp / 2) / QPtmp; + + + if (bACPredEnable) + { + /***********************/ + /* Find AC prediction */ + /***********************/ + + if ((x_pos == 0) && y_pos == 0) /* top left corner */ + { + if (direction[comp] == 0) + { + if (comp == 1 || comp == 3) + { + QPtmp = QPMB[mbnum+x_offset]; + DCAC = DCAC_col[0][b_ytab]; + if (QPtmp != QP) + { + predptr = pred; + PREDICT_AC + } + else + { + predptr = DCAC; + } + } + else + { + predptr = pred; + pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0; + } + } + else + { + if (comp == 2 || comp == 3) + { + QPtmp = QPMB[mbnum+ y_offset]; + DCAC = DCAC_row[x_pos][b_xtab]; + if (QPtmp != QP) + { + predptr = pred; + PREDICT_AC + } + else + { + predptr = DCAC; + } + } + else + { + predptr = pred; + pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0; + } + } + } + else if (x_pos == 0) /* left edge */ + { + if (direction[comp] == 0) + { + if (comp == 1 || comp == 3) + { + QPtmp = QPMB[mbnum+x_offset]; + DCAC = DCAC_col[0][b_ytab]; + if (QPtmp != QP) + { + predptr = pred; + PREDICT_AC + } + else + { + predptr = DCAC; + } + } + else + { + predptr = pred; + pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0; + } + } + else + { + + if ((Pos0[comp] && (slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow])) + || comp == 2 || comp == 3) + { + QPtmp = QPMB[mbnum+y_offset]; + DCAC = DCAC_row[x_pos][b_xtab]; + if (QPtmp != QP) + { + predptr = pred; + PREDICT_AC + } + else + { + predptr = DCAC; + } + } + else + { + predptr = pred; + pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0; + } + } + } + else if (y_pos == 0) /* top row */ + { + if (direction[comp] == 0) + { + if ((Pos1[comp] && (slice_nb[mbnum] == slice_nb[mbnum-1])) + || comp == 1 || comp == 3) + { + QPtmp = QPMB[mbnum+x_offset]; + DCAC = DCAC_col[0][b_ytab]; + if (QPtmp != QP) + { + predptr = pred; + PREDICT_AC + } + else + { + predptr = DCAC; + } + } + else + { + predptr = pred; + pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0; + } + } + else + { + if (comp == 2 || comp == 3) + { + QPtmp = QPMB[mbnum+y_offset]; + DCAC = DCAC_row[x_pos][b_xtab]; + if (QPtmp != QP) + { + predptr = pred; + PREDICT_AC + } + else + { + predptr = DCAC; + } + } + else + { + predptr = pred; + pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0; + } + } + } + else + { + if (direction[comp] == 0) + { + if ((Pos1[comp] && (slice_nb[mbnum] == slice_nb[mbnum-1])) + || comp == 1 || comp == 3) + { + QPtmp = QPMB[mbnum+x_offset]; + DCAC = DCAC_col[0][b_ytab]; + if (QPtmp != QP) + { + predptr = pred; + PREDICT_AC + } + else + { + predptr = DCAC; + } + } + else + { + predptr = pred; + pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0; + } + } + else + { + if ((Pos0[comp] && (slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow])) + || comp == 2 || comp == 3) + { + QPtmp = QPMB[mbnum+y_offset]; + DCAC = DCAC_row[x_pos][b_xtab]; + if (QPtmp != QP) + { + predptr = pred; + PREDICT_AC + } + else + { + predptr = DCAC; + } + } + else + { + predptr = pred; + pred[0] = pred[1] = pred[2] = pred[3] = pred[4] = pred[5] = pred[6] = 0; + } + } + } + + /************************************/ + /* Decide and Perform AC prediction */ + /************************************/ + newCBP[comp] = 0; + + if (direction[comp] == 0) /* Horizontal, left COLUMN of block A */ + { + DCAC = pcoeff + comp * 7; /* re-use DCAC as local var */ + qcoeff += 8; + for (m = 0; m < 7; m++) + { + QPtmp = qcoeff[m<<3]; + if (QPtmp > 0) S1 += QPtmp; + else S1 -= QPtmp; + QPtmp -= predptr[m]; + DCAC[m] = QPtmp; /* save prediction residue to pcoeff*/ + if (QPtmp) newCBP[comp] = 1; + diff = PV_ABS(QPtmp); + S2 += diff; + } + } + else /* Vertical, top ROW of block C */ + { + qcoeff++; + DCAC = pcoeff + comp * 7; /* re-use DCAC as local var */ + for (m = 0; m < 7; m++) + { + QPtmp = qcoeff[m]; + if (QPtmp > 0) S1 += QPtmp; + else S1 -= QPtmp; + QPtmp -= predptr[m]; + DCAC[m] = QPtmp; /* save prediction residue to pcoeff*/ + if (QPtmp) newCBP[comp] = 1; + diff = PV_ABS(QPtmp); + S2 += diff; + } + } + + /****************************/ + /* Store DCAC coefficients */ + /****************************/ + /* Store coeff values for Intra MB */ + qcoeff = MB->block[comp]; + DCAC = DCAC_row[x_pos][b_xtab]; + DCAC[0] = qcoeff[1]; + DCAC[1] = qcoeff[2]; + DCAC[2] = qcoeff[3]; + DCAC[3] = qcoeff[4]; + DCAC[4] = qcoeff[5]; + DCAC[5] = qcoeff[6]; + DCAC[6] = qcoeff[7]; + + DCAC = DCAC_col[0][b_ytab]; + DCAC[0] = qcoeff[8]; + DCAC[1] = qcoeff[16]; + DCAC[2] = qcoeff[24]; + DCAC[3] = qcoeff[32]; + DCAC[4] = qcoeff[40]; + DCAC[5] = qcoeff[48]; + DCAC[6] = qcoeff[56]; + + + } /* bACPredEnable */ + + } /* END COMP FOR LOOP */ + + //if (diff > 2047) + // break; + S += (S1 - S2); + + + if (S >= 0 && bACPredEnable == TRUE) + { + ACpred_flag[mbnum] = 1; + DCAC = pcoeff; /* prediction residue */ + qcoeff = MB->block[0]; + + for (comp = 0; comp < 6; comp++) + { + if (direction[comp] == 0) + { + qcoeff[8] = DCAC[0]; + qcoeff[16] = DCAC[1]; + qcoeff[24] = DCAC[2]; + qcoeff[32] = DCAC[3]; + qcoeff[40] = DCAC[4]; + qcoeff[48] = DCAC[5]; + qcoeff[56] = DCAC[6]; + + } + else + { + qcoeff[1] = DCAC[0]; + qcoeff[2] = DCAC[1]; + qcoeff[3] = DCAC[2]; + qcoeff[4] = DCAC[3]; + qcoeff[5] = DCAC[4]; + qcoeff[6] = DCAC[5]; + qcoeff[7] = DCAC[6]; + } + if (newCBP[comp]) /* 5/28/01, update CBP */ + video->headerInfo.CBP[mbnum] |= mask1[comp]; + DCAC += 7; + qcoeff += 64; + } + } + else /* Only DC Prediction */ + { + ACpred_flag[mbnum] = 0; + } + + *intraDC_decision = IntraDCSwitch_Decision(Mode, video->currVop->intraDCVlcThr, intraDCVlcQP); + if (*intraDC_decision) /* code DC with AC , 5/28/01*/ + { + qcoeff = MB->block[0]; + for (comp = 0; comp < 6; comp++) + { + if (*qcoeff) + video->headerInfo.CBP[mbnum] |= mask1[comp]; + qcoeff += 64; + } + } + return; +} +#endif /* H263_ONLY */ + + + +Void find_pmvs(VideoEncData *video, Int block, Int *mvx, Int *mvy) +{ + Vol *currVol = video->vol[video->currLayer]; +// UChar *Mode = video->headerInfo.Mode; /* modes for MBs */ + UChar *slice_nb = video->sliceNo; + Int nMBPerRow = currVol->nMBPerRow; + Int mbnum = video->mbnum; + + Int p1x, p2x, p3x; + Int p1y, p2y, p3y; + Int xin1, xin2, xin3; + Int yin1, yin2, yin3; + Int vec1, vec2, vec3; + Int rule1, rule2, rule3; + MOT **motdata = video->mot; + Int x = mbnum % nMBPerRow; + Int y = mbnum / nMBPerRow; + + /* + In a previous version, a MB vector (block = 0) was predicted the same way + as block 1, which is the most likely interpretation of the VM. + + Therefore, if we have advanced pred. mode, and if all MBs around have + only one 16x16 vector each, we chose the appropiate block as if these + MBs have 4 vectors. + + This different prediction affects only 16x16 vectors of MBs with + transparent blocks. + + In the current version, we choose for the 16x16 mode the first + non-transparent block in the surrounding MBs + */ + + switch (block) + { + case 0: + vec1 = 2 ; + yin1 = y ; + xin1 = x - 1; + vec2 = 3 ; + yin2 = y - 1; + xin2 = x; + vec3 = 3 ; + yin3 = y - 1; + xin3 = x + 1; + break; + + case 1: + vec1 = 2 ; + yin1 = y ; + xin1 = x - 1; + vec2 = 3 ; + yin2 = y - 1; + xin2 = x; + vec3 = 3 ; + yin3 = y - 1; + xin3 = x + 1; + break; + + case 2: + vec1 = 1 ; + yin1 = y ; + xin1 = x; + vec2 = 4 ; + yin2 = y - 1; + xin2 = x; + vec3 = 3 ; + yin3 = y - 1; + xin3 = x + 1; + break; + + case 3: + vec1 = 4 ; + yin1 = y ; + xin1 = x - 1; + vec2 = 1 ; + yin2 = y ; + xin2 = x; + vec3 = 2 ; + yin3 = y ; + xin3 = x; + break; + + default: /* case 4 */ + vec1 = 3 ; + yin1 = y ; + xin1 = x; + vec2 = 1 ; + yin2 = y ; + xin2 = x; + vec3 = 2 ; + yin3 = y ; + xin3 = x; + break; + } + + if (block == 0) + { + /* according to the motion encoding, we must choose a first non-transparent + block in the surrounding MBs (16-mode) + */ + + if (x > 0 && slice_nb[mbnum] == slice_nb[mbnum-1]) + rule1 = 0; + else + rule1 = 1; + + if (y > 0 && slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow]) + rule2 = 0; + else + rule2 = 1; + + if ((x != nMBPerRow - 1) && (y > 0) && slice_nb[mbnum] == slice_nb[mbnum+1-nMBPerRow]) + rule3 = 0; + else + rule3 = 1; + } + else + { + /* check borders for single blocks (advanced mode) */ + /* rule 1 */ + if (((block == 1 || block == 3) && + (x == 0 || slice_nb[mbnum] != slice_nb[mbnum-1]))) + rule1 = 1; + else + rule1 = 0; + + /* rule 2 */ + if (((block == 1 || block == 2) && + (y == 0 || slice_nb[mbnum] != slice_nb[mbnum-nMBPerRow]))) + rule2 = 1; + else + rule2 = 0; + + /* rule 3 */ + if (((block == 1 || block == 2) && + (x == nMBPerRow - 1 || y == 0 || slice_nb[mbnum] != slice_nb[mbnum+1-nMBPerRow]))) + rule3 = 1; + else + rule3 = 0; + } + + if (rule1) + { + p1x = p1y = 0; + } + else + { + + p1x = motdata[yin1*nMBPerRow+xin1][vec1].x; + p1y = motdata[yin1*nMBPerRow+xin1][vec1].y; + //p1x = motxdata[xin1*2+(vec1&0x1) + (yin1*2+(vec1>>1))*xB]; + //p1y = motydata[xin1*2+(vec1&0x1) + (yin1*2+(vec1>>1))*xB]; + } + + if (rule2) + { + p2x = p2y = 0; + } + else + { + p2x = motdata[yin2*nMBPerRow+xin2][vec2].x; + p2y = motdata[yin2*nMBPerRow+xin2][vec2].y; + //p2x = motxdata[xin2*2+(vec2&0x1) + (yin2*2+(vec2>>1))*xB]; + //p2y = motydata[xin2*2+(vec2&0x1) + (yin2*2+(vec2>>1))*xB]; + } + + if (rule3) + { + p3x = p3y = 0; + } + else + { + p3x = motdata[yin3*nMBPerRow+xin3][vec3].x; + p3y = motdata[yin3*nMBPerRow+xin3][vec3].y; + //p3x = motxdata[xin3*2+ (vec3&0x1) + (yin3*2+(vec3>>1))*xB]; + //p3y = motydata[xin3*2+ (vec3&0x1) + (yin3*2+(vec3>>1))*xB]; + } + + if (rule1 && rule2 && rule3) + { + /* all MBs are outside the VOP */ + *mvx = *mvy = 0; + } + else if (rule1 + rule2 + rule3 == 2) + { + /* two of three are zero */ + *mvx = (p1x + p2x + p3x); + *mvy = (p1y + p2y + p3y); + } + else + { + *mvx = ((p1x + p2x + p3x - PV_MAX(p1x, PV_MAX(p2x, p3x)) - PV_MIN(p1x, PV_MIN(p2x, p3x)))); + *mvy = ((p1y + p2y + p3y - PV_MAX(p1y, PV_MAX(p2y, p3y)) - PV_MIN(p1y, PV_MIN(p2y, p3y)))); + } + + return; +} + + +Void WriteMVcomponent(Int f_code, Int dmv, BitstreamEncVideo *bs) +{ + Int residual, vlc_code_mag, bits, entry; + + ScaleMVD(f_code, dmv, &residual, &vlc_code_mag); + + if (vlc_code_mag < 0) + entry = vlc_code_mag + 65; + else + entry = vlc_code_mag; + + bits = PutMV(entry, bs); + + if ((f_code != 1) && (vlc_code_mag != 0)) + { + BitstreamPutBits(bs, f_code - 1, residual); + bits += f_code - 1; + } + return; +} + + +Void +ScaleMVD( + Int f_code, /* <-- MV range in 1/2 units: 1=32,2=64,...,7=2048 */ + Int diff_vector, /* <-- MV Difference commponent in 1/2 units */ + Int *residual, /* --> value to be FLC coded */ + Int *vlc_code_mag /* --> value to be VLC coded */ +) +{ + Int range; + Int scale_factor; + Int r_size; + Int low; + Int high; + Int aux; + + r_size = f_code - 1; + scale_factor = 1 << r_size; + range = 32 * scale_factor; + low = -range; + high = range - 1; + + if (diff_vector < low) + diff_vector += 2 * range; + else if (diff_vector > high) + diff_vector -= 2 * range; + + if (diff_vector == 0) + { + *vlc_code_mag = 0; + *residual = 0; + } + else if (scale_factor == 1) + { + *vlc_code_mag = diff_vector; + *residual = 0; + } + else + { + aux = PV_ABS(diff_vector) + scale_factor - 1; + *vlc_code_mag = aux >> r_size; + + if (diff_vector < 0) + *vlc_code_mag = -*vlc_code_mag; + *residual = aux & (scale_factor - 1); + } +} |