• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

libavcodec/h264enc.c

Go to the documentation of this file.
00001 /*
00002  * H.264 encoder
00003  *
00004  * This file is part of FFmpeg.
00005  *
00006  * FFmpeg is free software; you can redistribute it and/or
00007  * modify it under the terms of the GNU Lesser General Public
00008  * License as published by the Free Software Foundation; either
00009  * version 2.1 of the License, or (at your option) any later version.
00010  *
00011  * FFmpeg is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014  * Lesser General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU Lesser General Public
00017  * License along with FFmpeg; if not, write to the Free Software
00018  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00019  */
00020 
00021 
00022 #include "libavutil/common.h"
00023 #include "get_bits.h"
00024 #include "mpegvideo.h"
00025 #include "h264data.h"
00026 
00036 static uint8_t *h264_write_nal_unit(int nal_ref_idc, int nal_unit_type, uint8_t *dest, int *destsize,
00037                           PutBitContext *b2)
00038 {
00039     PutBitContext b;
00040     int i, destpos, rbsplen, escape_count;
00041     uint8_t *rbsp;
00042 
00043     if (nal_unit_type != NAL_END_STREAM)
00044         put_bits(b2,1,1); // rbsp_stop_bit
00045 
00046     // Align b2 on a byte boundary
00047     align_put_bits(b2);
00048     rbsplen = put_bits_count(b2)/8;
00049     flush_put_bits(b2);
00050     rbsp = b2->buf;
00051 
00052     init_put_bits(&b,dest,*destsize);
00053 
00054     put_bits(&b,16,0);
00055     put_bits(&b,16,0x01);
00056 
00057     put_bits(&b,1,0); // forbidden zero bit
00058     put_bits(&b,2,nal_ref_idc); // nal_ref_idc
00059     put_bits(&b,5,nal_unit_type); // nal_unit_type
00060 
00061     flush_put_bits(&b);
00062 
00063     destpos = 5;
00064     escape_count= 0;
00065 
00066     for (i=0; i<rbsplen; i+=2)
00067     {
00068         if (rbsp[i]) continue;
00069         if (i>0 && rbsp[i-1]==0)
00070             i--;
00071         if (i+2<rbsplen && rbsp[i+1]==0 && rbsp[i+2]<=3)
00072         {
00073             escape_count++;
00074             i+=2;
00075         }
00076     }
00077 
00078     if(escape_count==0)
00079     {
00080         if(dest+destpos != rbsp)
00081         {
00082             memcpy(dest+destpos, rbsp, rbsplen);
00083             *destsize -= (rbsplen+destpos);
00084         }
00085         return dest+rbsplen+destpos;
00086     }
00087 
00088     if(rbsplen + escape_count + 1> *destsize)
00089     {
00090         av_log(NULL, AV_LOG_ERROR, "Destination buffer too small!\n");
00091         return NULL;
00092     }
00093 
00094     // this should be damn rare (hopefully)
00095     for (i = 0 ; i < rbsplen ; i++)
00096     {
00097         if (i + 2 < rbsplen && (rbsp[i] == 0 && rbsp[i+1] == 0 && rbsp[i+2] < 4))
00098         {
00099             dest[destpos++] = rbsp[i++];
00100             dest[destpos++] = rbsp[i];
00101             dest[destpos++] = 0x03; // emulation prevention byte
00102         }
00103         else
00104             dest[destpos++] = rbsp[i];
00105     }
00106     *destsize -= destpos;
00107     return dest+destpos;
00108 }
00109 
00110 static const uint8_t pict_type_to_golomb[7] = {-1, 2, 0, 1, -1, 4, 3};
00111 
00112 static const uint8_t intra4x4_cbp_to_golomb[48] = {
00113     3, 29, 30, 17, 31, 18, 37,  8, 32, 38, 19,  9, 20, 10, 11,  2,
00114    16, 33, 34, 21, 35, 22, 39,  4, 36, 40, 23,  5, 24,  6,  7,  1,
00115    41, 42, 43, 25, 44, 26, 46, 12, 45, 47, 27, 13, 28, 14, 15,  0
00116 };
00117 
00118 static const uint8_t inter_cbp_to_golomb[48] = {
00119     0,  2,  3,  7,  4,  8, 17, 13,  5, 18,  9, 14, 10, 15, 16, 11,
00120     1, 32, 33, 36, 34, 37, 44, 40, 35, 45, 38, 41, 39, 42, 43, 19,
00121     6, 24, 25, 20, 26, 21, 46, 28, 27, 47, 22, 29, 23, 30, 31, 12
00122 };
00123 
00124 #define QUANT_SHIFT 22
00125 
00126 static const int quant_coeff[52][16] = {
00127     { 419430, 258111, 419430, 258111, 258111, 167772, 258111, 167772, 419430, 258111, 419430, 258111, 258111, 167772, 258111, 167772,},
00128     { 381300, 239675, 381300, 239675, 239675, 149131, 239675, 149131, 381300, 239675, 381300, 239675, 239675, 149131, 239675, 149131,},
00129     { 322639, 209715, 322639, 209715, 209715, 134218, 209715, 134218, 322639, 209715, 322639, 209715, 209715, 134218, 209715, 134218,},
00130     { 299593, 186414, 299593, 186414, 186414, 116711, 186414, 116711, 299593, 186414, 299593, 186414, 186414, 116711, 186414, 116711,},
00131     { 262144, 167772, 262144, 167772, 167772, 107374, 167772, 107374, 262144, 167772, 262144, 167772, 167772, 107374, 167772, 107374,},
00132     { 233017, 145889, 233017, 145889, 145889,  92564, 145889,  92564, 233017, 145889, 233017, 145889, 145889,  92564, 145889,  92564,},
00133     { 209715, 129056, 209715, 129056, 129056,  83886, 129056,  83886, 209715, 129056, 209715, 129056, 129056,  83886, 129056,  83886,},
00134     { 190650, 119837, 190650, 119837, 119837,  74565, 119837,  74565, 190650, 119837, 190650, 119837, 119837,  74565, 119837,  74565,},
00135     { 161319, 104858, 161319, 104858, 104858,  67109, 104858,  67109, 161319, 104858, 161319, 104858, 104858,  67109, 104858,  67109,},
00136     { 149797,  93207, 149797,  93207,  93207,  58356,  93207,  58356, 149797,  93207, 149797,  93207,  93207,  58356,  93207,  58356,},
00137     { 131072,  83886, 131072,  83886,  83886,  53687,  83886,  53687, 131072,  83886, 131072,  83886,  83886,  53687,  83886,  53687,},
00138     { 116508,  72944, 116508,  72944,  72944,  46282,  72944,  46282, 116508,  72944, 116508,  72944,  72944,  46282,  72944,  46282,},
00139     { 104858,  64528, 104858,  64528,  64528,  41943,  64528,  41943, 104858,  64528, 104858,  64528,  64528,  41943,  64528,  41943,},
00140     {  95325,  59919,  95325,  59919,  59919,  37283,  59919,  37283,  95325,  59919,  95325,  59919,  59919,  37283,  59919,  37283,},
00141     {  80660,  52429,  80660,  52429,  52429,  33554,  52429,  33554,  80660,  52429,  80660,  52429,  52429,  33554,  52429,  33554,},
00142     {  74898,  46603,  74898,  46603,  46603,  29178,  46603,  29178,  74898,  46603,  74898,  46603,  46603,  29178,  46603,  29178,},
00143     {  65536,  41943,  65536,  41943,  41943,  26844,  41943,  26844,  65536,  41943,  65536,  41943,  41943,  26844,  41943,  26844,},
00144     {  58254,  36472,  58254,  36472,  36472,  23141,  36472,  23141,  58254,  36472,  58254,  36472,  36472,  23141,  36472,  23141,},
00145     {  52429,  32264,  52429,  32264,  32264,  20972,  32264,  20972,  52429,  32264,  52429,  32264,  32264,  20972,  32264,  20972,},
00146     {  47663,  29959,  47663,  29959,  29959,  18641,  29959,  18641,  47663,  29959,  47663,  29959,  29959,  18641,  29959,  18641,},
00147     {  40330,  26214,  40330,  26214,  26214,  16777,  26214,  16777,  40330,  26214,  40330,  26214,  26214,  16777,  26214,  16777,},
00148     {  37449,  23302,  37449,  23302,  23302,  14589,  23302,  14589,  37449,  23302,  37449,  23302,  23302,  14589,  23302,  14589,},
00149     {  32768,  20972,  32768,  20972,  20972,  13422,  20972,  13422,  32768,  20972,  32768,  20972,  20972,  13422,  20972,  13422,},
00150     {  29127,  18236,  29127,  18236,  18236,  11570,  18236,  11570,  29127,  18236,  29127,  18236,  18236,  11570,  18236,  11570,},
00151     {  26214,  16132,  26214,  16132,  16132,  10486,  16132,  10486,  26214,  16132,  26214,  16132,  16132,  10486,  16132,  10486,},
00152     {  23831,  14980,  23831,  14980,  14980,   9321,  14980,   9321,  23831,  14980,  23831,  14980,  14980,   9321,  14980,   9321,},
00153     {  20165,  13107,  20165,  13107,  13107,   8389,  13107,   8389,  20165,  13107,  20165,  13107,  13107,   8389,  13107,   8389,},
00154     {  18725,  11651,  18725,  11651,  11651,   7294,  11651,   7294,  18725,  11651,  18725,  11651,  11651,   7294,  11651,   7294,},
00155     {  16384,  10486,  16384,  10486,  10486,   6711,  10486,   6711,  16384,  10486,  16384,  10486,  10486,   6711,  10486,   6711,},
00156     {  14564,   9118,  14564,   9118,   9118,   5785,   9118,   5785,  14564,   9118,  14564,   9118,   9118,   5785,   9118,   5785,},
00157     {  13107,   8066,  13107,   8066,   8066,   5243,   8066,   5243,  13107,   8066,  13107,   8066,   8066,   5243,   8066,   5243,},
00158     {  11916,   7490,  11916,   7490,   7490,   4660,   7490,   4660,  11916,   7490,  11916,   7490,   7490,   4660,   7490,   4660,},
00159     {  10082,   6554,  10082,   6554,   6554,   4194,   6554,   4194,  10082,   6554,  10082,   6554,   6554,   4194,   6554,   4194,},
00160     {   9362,   5825,   9362,   5825,   5825,   3647,   5825,   3647,   9362,   5825,   9362,   5825,   5825,   3647,   5825,   3647,},
00161     {   8192,   5243,   8192,   5243,   5243,   3355,   5243,   3355,   8192,   5243,   8192,   5243,   5243,   3355,   5243,   3355,},
00162     {   7282,   4559,   7282,   4559,   4559,   2893,   4559,   2893,   7282,   4559,   7282,   4559,   4559,   2893,   4559,   2893,},
00163     {   6554,   4033,   6554,   4033,   4033,   2621,   4033,   2621,   6554,   4033,   6554,   4033,   4033,   2621,   4033,   2621,},
00164     {   5958,   3745,   5958,   3745,   3745,   2330,   3745,   2330,   5958,   3745,   5958,   3745,   3745,   2330,   3745,   2330,},
00165     {   5041,   3277,   5041,   3277,   3277,   2097,   3277,   2097,   5041,   3277,   5041,   3277,   3277,   2097,   3277,   2097,},
00166     {   4681,   2913,   4681,   2913,   2913,   1824,   2913,   1824,   4681,   2913,   4681,   2913,   2913,   1824,   2913,   1824,},
00167     {   4096,   2621,   4096,   2621,   2621,   1678,   2621,   1678,   4096,   2621,   4096,   2621,   2621,   1678,   2621,   1678,},
00168     {   3641,   2280,   3641,   2280,   2280,   1446,   2280,   1446,   3641,   2280,   3641,   2280,   2280,   1446,   2280,   1446,},
00169     {   3277,   2016,   3277,   2016,   2016,   1311,   2016,   1311,   3277,   2016,   3277,   2016,   2016,   1311,   2016,   1311,},
00170     {   2979,   1872,   2979,   1872,   1872,   1165,   1872,   1165,   2979,   1872,   2979,   1872,   1872,   1165,   1872,   1165,},
00171     {   2521,   1638,   2521,   1638,   1638,   1049,   1638,   1049,   2521,   1638,   2521,   1638,   1638,   1049,   1638,   1049,},
00172     {   2341,   1456,   2341,   1456,   1456,    912,   1456,    912,   2341,   1456,   2341,   1456,   1456,    912,   1456,    912,},
00173     {   2048,   1311,   2048,   1311,   1311,    839,   1311,    839,   2048,   1311,   2048,   1311,   1311,    839,   1311,    839,},
00174     {   1820,   1140,   1820,   1140,   1140,    723,   1140,    723,   1820,   1140,   1820,   1140,   1140,    723,   1140,    723,},
00175     {   1638,   1008,   1638,   1008,   1008,    655,   1008,    655,   1638,   1008,   1638,   1008,   1008,    655,   1008,    655,},
00176     {   1489,    936,   1489,    936,    936,    583,    936,    583,   1489,    936,   1489,    936,    936,    583,    936,    583,},
00177     {   1260,    819,   1260,    819,    819,    524,    819,    524,   1260,    819,   1260,    819,    819,    524,    819,    524,},
00178     {   1170,    728,   1170,    728,    728,    456,    728,    456,   1170,    728,   1170,    728,    728,    456,    728,    456,},
00179 };
00180 
00181 //FIXME need to check that this does not overflow signed 32 bit for low qp, I am not sure, it's very close
00182 //FIXME check that gcc inlines this (and optimizes intra & separate_dc stuff away)
00183 static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale,
00184                              int intra, int separate_dc)
00185 {
00186     int i;
00187     const int * const quant_table = quant_coeff[qscale];
00188     const int bias = intra ? (1 << QUANT_SHIFT) / 3 : (1 << QUANT_SHIFT) / 6;
00189     const unsigned int threshold1 = (1 << QUANT_SHIFT) - bias - 1;
00190     const unsigned int threshold2 = (threshold1 << 1);
00191     int last_non_zero;
00192 
00193     if (separate_dc) {
00194         if (qscale <= 18) {
00195             //avoid overflows
00196             const int dc_bias = intra ? (1 << (QUANT_SHIFT - 2)) / 3 : (1 << (QUANT_SHIFT - 2)) / 6;
00197             const unsigned int dc_threshold1 = (1 << (QUANT_SHIFT - 2)) - dc_bias - 1;
00198             const unsigned int dc_threshold2 = (dc_threshold1 << 1);
00199 
00200             int level = block[0]*quant_coeff[qscale+18][0];
00201             if (((unsigned)(level + dc_threshold1)) > dc_threshold2) {
00202                 if (level > 0) {
00203                     level = (dc_bias + level) >> (QUANT_SHIFT - 2);
00204                     block[0] = level;
00205                 } else {
00206                     level = (dc_bias - level) >> (QUANT_SHIFT - 2);
00207                     block[0] = -level;
00208                 }
00209 //                last_non_zero = i;
00210             } else {
00211                 block[0] = 0;
00212             }
00213         } else {
00214             const int dc_bias = intra ? (1 << (QUANT_SHIFT + 1)) / 3 : (1 << (QUANT_SHIFT + 1)) / 6;
00215             const unsigned int dc_threshold1 = (1 << (QUANT_SHIFT + 1)) - dc_bias - 1;
00216             const unsigned int dc_threshold2 = (dc_threshold1 << 1);
00217 
00218             int level = block[0]*quant_table[0];
00219             if (((unsigned)(level + dc_threshold1)) > dc_threshold2) {
00220                 if (level > 0) {
00221                     level = (dc_bias + level) >> (QUANT_SHIFT + 1);
00222                     block[0] = level;
00223                 } else {
00224                     level = (dc_bias - level) >> (QUANT_SHIFT + 1);
00225                     block[0] = -level;
00226                 }
00227 //                last_non_zero = i;
00228             } else {
00229                 block[0] = 0;
00230             }
00231         }
00232         last_non_zero = 0;
00233         i = 1;
00234     } else {
00235         last_non_zero = -1;
00236         i = 0;
00237     }
00238 
00239     for (; i < 16; i++) {
00240         const int j = scantable[i];
00241         int level = block[j]*quant_table[j];
00242 
00243 //        if (   bias+level >= (1 << (QMAT_SHIFT - 3))
00244 //            || bias-level >= (1 << (QMAT_SHIFT - 3))) {
00245         if (((unsigned)(level + threshold1)) > threshold2) {
00246             if (level > 0) {
00247                 level = (bias + level) >> QUANT_SHIFT;
00248                 block[j] = level;
00249             } else {
00250                 level = (bias - level) >> QUANT_SHIFT;
00251                 block[j] = -level;
00252             }
00253             last_non_zero = i;
00254         } else {
00255             block[j] = 0;
00256         }
00257     }
00258 
00259     return last_non_zero;
00260 }

Generated on Fri Sep 16 2011 17:17:37 for FFmpeg by  doxygen 1.7.1