Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h264enc.c @ 9106a698

History | View | Annotate | Download (13.5 KB)

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
}