cosmetics, rename loop to frame_available
[ffmpeg.git] / 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  * @return 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_table = 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 }