libavcodec/h264enc.c

   1 /*
   2  * H.264 encoder
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21
  22 #include "libavutil/common.h"
  23 #include "get_bits.h"
  24 #include "mpegvideo.h"
  25 #include "h264data.h"
  26
  27 /**
  28  * Write out the provided data into a NAL unit.
  29  * @param nal_ref_idc NAL reference IDC
  30  * @param nal_unit_type NAL unit payload type
  31  * @param dest the target buffer, dst+1 == src is allowed as a special case
  32  * @param destsize the length of the dst array
  33  * @param b2 the data which should be escaped
  34  * @returns pointer to current position in the output buffer or NULL if an error occurred
  35  */
  36 static uint8_t *h264_write_nal_unit(int nal_ref_idc, int nal_unit_type, uint8_t *dest, int *destsize,
  37                           PutBitContext *b2)
  38 {
  39     PutBitContext b;
  40     int i, destpos, rbsplen, escape_count;
  41     uint8_t *rbsp;
  42
  43     if (nal_unit_type != NAL_END_STREAM)
  44         put_bits(b2,1,1); // rbsp_stop_bit
  45
  46     // Align b2 on a byte boundary
  47     align_put_bits(b2);
  48     rbsplen = put_bits_count(b2)/8;
  49     flush_put_bits(b2);
  50     rbsp = b2->buf;
  51
  52     init_put_bits(&b,dest,*destsize);
  53
  54     put_bits(&b,16,0);
  55     put_bits(&b,16,0x01);
  56
  57     put_bits(&b,1,0); // forbidden zero bit
  58     put_bits(&b,2,nal_ref_idc); // nal_ref_idc
  59     put_bits(&b,5,nal_unit_type); // nal_unit_type
  60
  61     flush_put_bits(&b);
  62
  63     destpos = 5;
  64     escape_count= 0;
  65
  66     for (i=0; i<rbsplen; i+=2)
  67     {
  68         if (rbsp[i]) continue;
  69         if (i>0 && rbsp[i-1]==0)
  70             i--;
  71         if (i+2<rbsplen && rbsp[i+1]==0 && rbsp[i+2]<=3)
  72         {
  73             escape_count++;
  74             i+=2;
  75         }
  76     }
  77
  78     if(escape_count==0)
  79     {
  80         if(dest+destpos != rbsp)
  81         {
  82             memcpy(dest+destpos, rbsp, rbsplen);
  83             *destsize -= (rbsplen+destpos);
  84         }
  85         return dest+rbsplen+destpos;
  86     }
  87
  88     if(rbsplen + escape_count + 1> *destsize)
  89     {
  90         av_log(NULL, AV_LOG_ERROR, "Destination buffer too small!\n");
  91         return NULL;
  92     }
  93
  94     // this should be damn rare (hopefully)
  95     for (i = 0 ; i < rbsplen ; i++)
  96     {
  97         if (i + 2 < rbsplen && (rbsp[i] == 0 && rbsp[i+1] == 0 && rbsp[i+2] < 4))
  98         {
  99             dest[destpos++] = rbsp[i++];
 100             dest[destpos++] = rbsp[i];
 101             dest[destpos++] = 0x03; // emulation prevention byte
 102         }
 103         else
 104             dest[destpos++] = rbsp[i];
 105     }
 106     *destsize -= destpos;
 107     return dest+destpos;
 108 }
 109
 110 static const uint8_t pict_type_to_golomb[7] = {-1, 2, 0, 1, -1, 4, 3};
 111
 112 static const uint8_t intra4x4_cbp_to_golomb[48] = {
 113     3, 29, 30, 17, 31, 18, 37,  8, 32, 38, 19,  9, 20, 10, 11,  2,
 114    16, 33, 34, 21, 35, 22, 39,  4, 36, 40, 23,  5, 24,  6,  7,  1,
 115    41, 42, 43, 25, 44, 26, 46, 12, 45, 47, 27, 13, 28, 14, 15,  0
 116 };
 117
 118 static const uint8_t inter_cbp_to_golomb[48] = {
 119     0,  2,  3,  7,  4,  8, 17, 13,  5, 18,  9, 14, 10, 15, 16, 11,
 120     1, 32, 33, 36, 34, 37, 44, 40, 35, 45, 38, 41, 39, 42, 43, 19,
 121     6, 24, 25, 20, 26, 21, 46, 28, 27, 47, 22, 29, 23, 30, 31, 12
 122 };
 123
 124 #define QUANT_SHIFT 22
 125
 126 static const int quant_coeff[52][16] = {
 127     { 419430, 258111, 419430, 258111, 258111, 167772, 258111, 167772, 419430, 258111, 419430, 258111, 258111, 167772, 258111, 167772,},
 128     { 381300, 239675, 381300, 239675, 239675, 149131, 239675, 149131, 381300, 239675, 381300, 239675, 239675, 149131, 239675, 149131,},
 129     { 322639, 209715, 322639, 209715, 209715, 134218, 209715, 134218, 322639, 209715, 322639, 209715, 209715, 134218, 209715, 134218,},
 130     { 299593, 186414, 299593, 186414, 186414, 116711, 186414, 116711, 299593, 186414, 299593, 186414, 186414, 116711, 186414, 116711,},
 131     { 262144, 167772, 262144, 167772, 167772, 107374, 167772, 107374, 262144, 167772, 262144, 167772, 167772, 107374, 167772, 107374,},
 132     { 233017, 145889, 233017, 145889, 145889,  92564, 145889,  92564, 233017, 145889, 233017, 145889, 145889,  92564, 145889,  92564,},
 133     { 209715, 129056, 209715, 129056, 129056,  83886, 129056,  83886, 209715, 129056, 209715, 129056, 129056,  83886, 129056,  83886,},
 134     { 190650, 119837, 190650, 119837, 119837,  74565, 119837,  74565, 190650, 119837, 190650, 119837, 119837,  74565, 119837,  74565,},
 135     { 161319, 104858, 161319, 104858, 104858,  67109, 104858,  67109, 161319, 104858, 161319, 104858, 104858,  67109, 104858,  67109,},
 136     { 149797,  93207, 149797,  93207,  93207,  58356,  93207,  58356, 149797,  93207, 149797,  93207,  93207,  58356,  93207,  58356,},
 137     { 131072,  83886, 131072,  83886,  83886,  53687,  83886,  53687, 131072,  83886, 131072,  83886,  83886,  53687,  83886,  53687,},
 138     { 116508,  72944, 116508,  72944,  72944,  46282,  72944,  46282, 116508,  72944, 116508,  72944,  72944,  46282,  72944,  46282,},
 139     { 104858,  64528, 104858,  64528,  64528,  41943,  64528,  41943, 104858,  64528, 104858,  64528,  64528,  41943,  64528,  41943,},
 140     {  95325,  59919,  95325,  59919,  59919,  37283,  59919,  37283,  95325,  59919,  95325,  59919,  59919,  37283,  59919,  37283,},
 141     {  80660,  52429,  80660,  52429,  52429,  33554,  52429,  33554,  80660,  52429,  80660,  52429,  52429,  33554,  52429,  33554,},
 142     {  74898,  46603,  74898,  46603,  46603,  29178,  46603,  29178,  74898,  46603,  74898,  46603,  46603,  29178,  46603,  29178,},
 143     {  65536,  41943,  65536,  41943,  41943,  26844,  41943,  26844,  65536,  41943,  65536,  41943,  41943,  26844,  41943,  26844,},
 144     {  58254,  36472,  58254,  36472,  36472,  23141,  36472,  23141,  58254,  36472,  58254,  36472,  36472,  23141,  36472,  23141,},
 145     {  52429,  32264,  52429,  32264,  32264,  20972,  32264,  20972,  52429,  32264,  52429,  32264,  32264,  20972,  32264,  20972,},
 146     {  47663,  29959,  47663,  29959,  29959,  18641,  29959,  18641,  47663,  29959,  47663,  29959,  29959,  18641,  29959,  18641,},
 147     {  40330,  26214,  40330,  26214,  26214,  16777,  26214,  16777,  40330,  26214,  40330,  26214,  26214,  16777,  26214,  16777,},
 148     {  37449,  23302,  37449,  23302,  23302,  14589,  23302,  14589,  37449,  23302,  37449,  23302,  23302,  14589,  23302,  14589,},
 149     {  32768,  20972,  32768,  20972,  20972,  13422,  20972,  13422,  32768,  20972,  32768,  20972,  20972,  13422,  20972,  13422,},
 150     {  29127,  18236,  29127,  18236,  18236,  11570,  18236,  11570,  29127,  18236,  29127,  18236,  18236,  11570,  18236,  11570,},
 151     {  26214,  16132,  26214,  16132,  16132,  10486,  16132,  10486,  26214,  16132,  26214,  16132,  16132,  10486,  16132,  10486,},
 152     {  23831,  14980,  23831,  14980,  14980,   9321,  14980,   9321,  23831,  14980,  23831,  14980,  14980,   9321,  14980,   9321,},
 153     {  20165,  13107,  20165,  13107,  13107,   8389,  13107,   8389,  20165,  13107,  20165,  13107,  13107,   8389,  13107,   8389,},
 154     {  18725,  11651,  18725,  11651,  11651,   7294,  11651,   7294,  18725,  11651,  18725,  11651,  11651,   7294,  11651,   7294,},
 155     {  16384,  10486,  16384,  10486,  10486,   6711,  10486,   6711,  16384,  10486,  16384,  10486,  10486,   6711,  10486,   6711,},
 156     {  14564,   9118,  14564,   9118,   9118,   5785,   9118,   5785,  14564,   9118,  14564,   9118,   9118,   5785,   9118,   5785,},
 157     {  13107,   8066,  13107,   8066,   8066,   5243,   8066,   5243,  13107,   8066,  13107,   8066,   8066,   5243,   8066,   5243,},
 158     {  11916,   7490,  11916,   7490,   7490,   4660,   7490,   4660,  11916,   7490,  11916,   7490,   7490,   4660,   7490,   4660,},
 159     {  10082,   6554,  10082,   6554,   6554,   4194,   6554,   4194,  10082,   6554,  10082,   6554,   6554,   4194,   6554,   4194,},
 160     {   9362,   5825,   9362,   5825,   5825,   3647,   5825,   3647,   9362,   5825,   9362,   5825,   5825,   3647,   5825,   3647,},
 161     {   8192,   5243,   8192,   5243,   5243,   3355,   5243,   3355,   8192,   5243,   8192,   5243,   5243,   3355,   5243,   3355,},
 162     {   7282,   4559,   7282,   4559,   4559,   2893,   4559,   2893,   7282,   4559,   7282,   4559,   4559,   2893,   4559,   2893,},
 163     {   6554,   4033,   6554,   4033,   4033,   2621,   4033,   2621,   6554,   4033,   6554,   4033,   4033,   2621,   4033,   2621,},
 164     {   5958,   3745,   5958,   3745,   3745,   2330,   3745,   2330,   5958,   3745,   5958,   3745,   3745,   2330,   3745,   2330,},
 165     {   5041,   3277,   5041,   3277,   3277,   2097,   3277,   2097,   5041,   3277,   5041,   3277,   3277,   2097,   3277,   2097,},
 166     {   4681,   2913,   4681,   2913,   2913,   1824,   2913,   1824,   4681,   2913,   4681,   2913,   2913,   1824,   2913,   1824,},
 167     {   4096,   2621,   4096,   2621,   2621,   1678,   2621,   1678,   4096,   2621,   4096,   2621,   2621,   1678,   2621,   1678,},
 168     {   3641,   2280,   3641,   2280,   2280,   1446,   2280,   1446,   3641,   2280,   3641,   2280,   2280,   1446,   2280,   1446,},
 169     {   3277,   2016,   3277,   2016,   2016,   1311,   2016,   1311,   3277,   2016,   3277,   2016,   2016,   1311,   2016,   1311,},
 170     {   2979,   1872,   2979,   1872,   1872,   1165,   1872,   1165,   2979,   1872,   2979,   1872,   1872,   1165,   1872,   1165,},
 171     {   2521,   1638,   2521,   1638,   1638,   1049,   1638,   1049,   2521,   1638,   2521,   1638,   1638,   1049,   1638,   1049,},
 172     {   2341,   1456,   2341,   1456,   1456,    912,   1456,    912,   2341,   1456,   2341,   1456,   1456,    912,   1456,    912,},
 173     {   2048,   1311,   2048,   1311,   1311,    839,   1311,    839,   2048,   1311,   2048,   1311,   1311,    839,   1311,    839,},
 174     {   1820,   1140,   1820,   1140,   1140,    723,   1140,    723,   1820,   1140,   1820,   1140,   1140,    723,   1140,    723,},
 175     {   1638,   1008,   1638,   1008,   1008,    655,   1008,    655,   1638,   1008,   1638,   1008,   1008,    655,   1008,    655,},
 176     {   1489,    936,   1489,    936,    936,    583,    936,    583,   1489,    936,   1489,    936,    936,    583,    936,    583,},
 177     {   1260,    819,   1260,    819,    819,    524,    819,    524,   1260,    819,   1260,    819,    819,    524,    819,    524,},
 178     {   1170,    728,   1170,    728,    728,    456,    728,    456,   1170,    728,   1170,    728,    728,    456,    728,    456,},
 179 };
 180
 181 //FIXME need to check that this does not overflow signed 32 bit for low qp, I am not sure, it's very close
 182 //FIXME check that gcc inlines this (and optimizes intra & separate_dc stuff away)
 183 static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale,
 184                              int intra, int separate_dc)
 185 {
 186     int i;
 187     const int * const quant_3Btable = quant_coeff[qscale];
 188     const int bias = intra ? (1 << QUANT_SHIFT) / 3 : (1 << QUANT_SHIFT) / 6;
 189     const unsigned int threshold1 = (1 << QUANT_SHIFT) - bias - 1;
 190     const unsigned int threshold2 = (threshold1 << 1);
 191     int last_non_zero;
 192
 193     if (separate_dc) {
 194         if (qscale <= 18) {
 195             //avoid overflows
 196             const int dc_bias = intra ? (1 << (QUANT_SHIFT - 2)) / 3 : (1 << (QUANT_SHIFT - 2)) / 6;
 197             const unsigned int dc_threshold1 = (1 << (QUANT_SHIFT - 2)) - dc_bias - 1;
 198             const unsigned int dc_threshold2 = (dc_threshold1 << 1);
 199
 200             int level = block[0]*quant_coeff[qscale+18][0];
 201             if (((unsigned)(level + dc_threshold1)) > dc_threshold2) {
 202                 if (level > 0) {
 203                     level = (dc_bias + level) >> (QUANT_SHIFT - 2);
 204                     block[0] = level;
 205                 } else {
 206                     level = (dc_bias - level) >> (QUANT_SHIFT - 2);
 207                     block[0] = -level;
 208                 }
 209 //                last_non_zero = i;
 210             } else {
 211                 block[0] = 0;
 212             }
 213         } else {
 214             const int dc_bias = intra ? (1 << (QUANT_SHIFT + 1)) / 3 : (1 << (QUANT_SHIFT + 1)) / 6;
 215             const unsigned int dc_threshold1 = (1 << (QUANT_SHIFT + 1)) - dc_bias - 1;
 216             const unsigned int dc_threshold2 = (dc_threshold1 << 1);
 217
 218             int level = block[0]*quant_table[0];
 219             if (((unsigned)(level + dc_threshold1)) > dc_threshold2) {
 220                 if (level > 0) {
 221                     level = (dc_bias + level) >> (QUANT_SHIFT + 1);
 222                     block[0] = level;
 223                 } else {
 224                     level = (dc_bias - level) >> (QUANT_SHIFT + 1);
 225                     block[0] = -level;
 226                 }
 227 //                last_non_zero = i;
 228             } else {
 229                 block[0] = 0;
 230             }
 231         }
 232         last_non_zero = 0;
 233         i = 1;
 234     } else {
 235         last_non_zero = -1;
 236         i = 0;
 237     }
 238
 239     for (; i < 16; i++) {
 240         const int j = scantable[i];
 241         int level = block[j]*quant_table[j];
 242
 243 //        if (   bias+level >= (1 << (QMAT_SHIFT - 3))
 244 //            || bias-level >= (1 << (QMAT_SHIFT - 3))) {
 245         if (((unsigned)(level + threshold1)) > threshold2) {
 246             if (level > 0) {
 247                 level = (bias + level) >> QUANT_SHIFT;
 248                 block[j] = level;
 249             } else {
 250                 level = (bias - level) >> QUANT_SHIFT;
 251                 block[j] = -level;
 252             }
 253             last_non_zero = i;
 254         } else {
 255             block[j] = 0;
 256         }
 257     }
 258
 259     return last_non_zero;
 260 }