| /* ------------------------------------------------------------------ |
| * 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); |
| } |
| } |
