2641
|
1 /*
|
|
2 * divx4_vbr.c
|
|
3 *
|
|
4 * Copyright (C) Thomas Östreich - June 2001
|
|
5 *
|
|
6 * 2-pass code OpenDivX port:
|
|
7 * Copyright (C) 2001 Christoph Lampert <gruel@gmx.de>
|
|
8 *
|
|
9 * This file is part of transcode, a linux video stream processing tool
|
|
10 *
|
|
11 * transcode is free software; you can redistribute it and/or modify
|
|
12 * it under the terms of the GNU General Public License as published by
|
|
13 * the Free Software Foundation; either version 2, or (at your option)
|
|
14 * any later version.
|
|
15 *
|
|
16 * transcode is distributed in the hope that it will be useful,
|
|
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
19 * GNU General Public License for more details.
|
|
20 *
|
|
21 * You should have received a copy of the GNU General Public License
|
|
22 * along with GNU Make; see the file COPYING. If not, write to
|
|
23 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
24 *
|
|
25 */
|
|
26
|
|
27
|
|
28 /**********************************************************
|
|
29 * Two-pass-code from OpenDivX *
|
|
30 * *
|
|
31 * Large parts of this code were taken from VbrControl() *
|
|
32 * from the OpenDivX project, (C) divxnetworks, *
|
|
33 * this code is published under DivX Open license, which *
|
|
34 * can be found... somewhere... oh, whatever... *
|
|
35 **********************************************************/
|
|
36
|
|
37 #include <stdio.h>
|
|
38 #include <stdlib.h>
|
2642
|
39 #include <string.h>
|
2641
|
40 #include <sys/stat.h>
|
|
41 #include <unistd.h>
|
|
42 #include <fcntl.h>
|
|
43 #include <dlfcn.h>
|
|
44 #include <math.h>
|
|
45
|
3917
|
46 #ifndef __FreeBSD__
|
2641
|
47 #include <stdint.h>
|
3917
|
48 #endif
|
2641
|
49
|
|
50 #include "config.h"
|
2642
|
51
|
|
52 #include "divx4_vbr.h"
|
|
53
|
|
54 //#include "transcode.h"
|
2641
|
55
|
|
56 #define FALSE 0
|
|
57 #define TRUE 1
|
|
58
|
|
59 /* Absolute maximum and minimum quantizers used in VBR modes */
|
|
60 static const int min_quantizer=1;
|
|
61 static const int max_quantizer=31;
|
|
62
|
|
63 /* Limits on frame-level deviation of quantizer ( higher values
|
|
64 correspond to frames with more changes and vice versa ) */
|
|
65 static const float min_quant_delta=-10.f;
|
|
66 static const float max_quant_delta=5.f;
|
|
67 /* Limits on stream-level deviation of quantizer ( used to make
|
|
68 overall bitrate of stream close to requested value ) */
|
|
69 static const float min_rc_quant_delta=.6f;
|
|
70 static const float max_rc_quant_delta=1.5f;
|
|
71
|
|
72 /* Crispness parameter controls threshold for decision whether
|
|
73 to skip the frame or to code it. */
|
|
74 //static const float max_crispness=100.f;
|
|
75 /* Maximum allowed number of skipped frames in a line. */
|
|
76 //static const int max_drops_line=0; // CHL We don't drop frames at the moment!
|
|
77
|
|
78
|
|
79 typedef struct entry_s
|
|
80 /* max 28 bytes/frame or 5 Mb for 2-hour movie */
|
|
81 {
|
|
82 int quant;
|
|
83 int text_bits;
|
|
84 int motion_bits;
|
|
85 int total_bits;
|
|
86 float mult;
|
|
87 short is_key_frame;
|
|
88 short drop;
|
|
89 } entry;
|
|
90
|
2642
|
91 static int m_iCount;
|
|
92 static int m_iQuant;
|
|
93 static int m_iCrispness;
|
|
94 static short m_bDrop;
|
|
95 static float m_fQuant;
|
2641
|
96
|
2642
|
97 static int64_t m_lEncodedBits;
|
|
98 static int64_t m_lExpectedBits;
|
2641
|
99
|
2642
|
100 static FILE *m_pFile;
|
2641
|
101
|
2642
|
102 static entry vFrame;
|
|
103 static entry *m_vFrames;
|
|
104 static long lFrameStart;
|
2641
|
105
|
2642
|
106 static int iNumFrames;
|
|
107 static int dummy;
|
2641
|
108
|
|
109
|
|
110 void VbrControl_init_1pass_vbr(int quality, int crispness)
|
|
111 {
|
|
112 m_fQuant=min_quantizer+((max_quantizer-min_quantizer)/6.)*(6-quality);
|
|
113 m_iCount=0;
|
|
114 m_bDrop=FALSE;
|
|
115 VbrControl_update_1pass_vbr();
|
|
116 }
|
|
117
|
|
118 int VbrControl_init_2pass_vbr_analysis(const char *filename, int quality)
|
|
119 {
|
|
120 m_pFile=fopen(filename, "wb");
|
|
121 if(m_pFile==0)
|
|
122 return -1;
|
|
123 m_iCount=0;
|
|
124 m_bDrop=FALSE;
|
|
125 fprintf(m_pFile, "##version 1\n");
|
|
126 fprintf(m_pFile, "quality %d\n", quality);
|
|
127 return 0;
|
|
128 }
|
|
129
|
|
130 int VbrControl_init_2pass_vbr_encoding(const char *filename, int bitrate, double framerate, int crispness, int quality)
|
|
131 {
|
|
132 int i;
|
|
133
|
|
134 int64_t text_bits=0;
|
|
135 int64_t total_bits=0;
|
|
136 int64_t complexity=0;
|
|
137 int64_t new_complexity=0;
|
|
138 int64_t motion_bits=0;
|
|
139 int64_t denominator=0;
|
|
140 float qual_multiplier=1.;
|
|
141 char head[20];
|
|
142
|
|
143 int64_t desired_bits;
|
|
144 int64_t non_text_bits;
|
|
145
|
|
146 float average_complexity;
|
|
147
|
|
148 m_pFile=fopen(filename, "rb");
|
|
149 if(m_pFile==0)
|
|
150 return -1;
|
|
151 m_bDrop=FALSE;
|
|
152 m_iCount=0;
|
|
153
|
|
154 fread(head, 10, 1, m_pFile);
|
|
155 if(!strncmp("##version ", head, 10))
|
|
156 {
|
|
157 int version;
|
|
158 int iOldQual;
|
|
159 float old_qual, new_qual;
|
|
160 fscanf(m_pFile, "%d\n", &version);
|
|
161 fscanf(m_pFile, "quality %d\n", &iOldQual);
|
|
162 switch(iOldQual)
|
|
163 {
|
|
164 case 5:
|
|
165 old_qual=1.f;
|
|
166 break;
|
|
167 case 4:
|
|
168 old_qual=1.1f;
|
|
169 break;
|
|
170 case 3:
|
|
171 old_qual=1.25f;
|
|
172 break;
|
|
173 case 2:
|
|
174 old_qual=1.4f;
|
|
175 break;
|
|
176 case 1:
|
|
177 old_qual=2.f;
|
|
178 break;
|
|
179 }
|
|
180 switch(quality)
|
|
181 {
|
|
182 case 5:
|
|
183 new_qual=1.f;
|
|
184 break;
|
|
185 case 4:
|
|
186 new_qual=1.1f;
|
|
187 break;
|
|
188 case 3:
|
|
189 new_qual=1.25f;
|
|
190 break;
|
|
191 case 2:
|
|
192 new_qual=1.4f;
|
|
193 break;
|
|
194 case 1:
|
|
195 new_qual=2.f;
|
|
196 break;
|
|
197 }
|
|
198 qual_multiplier=new_qual/old_qual;
|
|
199 }
|
|
200 else
|
|
201 fseek(m_pFile, 0, SEEK_SET);
|
|
202
|
|
203 lFrameStart=ftell(m_pFile); // save current position
|
|
204
|
|
205 /* removed C++ dependencies, now read file twice :-( */
|
|
206
|
|
207
|
|
208 while(!feof(m_pFile))
|
|
209 { fscanf(m_pFile, "Frame %d: intra %d, quant %d, texture %d, motion %d, total %d\n",
|
|
210 &iNumFrames, &(vFrame.is_key_frame), &(vFrame.quant), &(vFrame.text_bits), &(vFrame.motion_bits), &(vFrame.total_bits));
|
|
211
|
|
212 vFrame.total_bits+=vFrame.text_bits*(qual_multiplier-1);
|
|
213 vFrame.text_bits*=qual_multiplier;
|
|
214 text_bits +=(int64_t)vFrame.text_bits;
|
|
215 motion_bits += (int64_t)vFrame.motion_bits;
|
|
216 total_bits +=(int64_t)vFrame.total_bits;
|
|
217 complexity +=(int64_t)vFrame.text_bits*vFrame.quant;
|
|
218
|
|
219 // printf("Frames %d, texture %d, motion %d, quant %d total %d ",
|
|
220 // iNumFrames, vFrame.text_bits, vFrame.motion_bits, vFrame.quant, vFrame.total_bits);
|
|
221 // printf("texture %d, total %d, complexity %lld \n",vFrame.text_bits,vFrame.total_bits, complexity);
|
|
222 }
|
|
223 iNumFrames++;
|
|
224 average_complexity=complexity/iNumFrames;
|
|
225
|
2642
|
226 // if (verbose & TC_DEBUG) {
|
|
227 // fprintf(stderr, "(%s) frames %d, texture %lld, motion %lld, total %lld, complexity %lld\n", __FILE__, iNumFrames, text_bits, motion_bits, total_bits, complexity);
|
|
228 // }
|
2641
|
229
|
|
230 m_vFrames = (entry*)malloc(iNumFrames*sizeof(entry));
|
|
231 if (!m_vFrames)
|
|
232 { printf("out of memory");
|
2642
|
233 return -2; //TC_EXPORT_ERROR;
|
2641
|
234 }
|
|
235
|
|
236 fseek(m_pFile, lFrameStart, SEEK_SET); // start again
|
|
237
|
|
238 for (i=0;i<iNumFrames;i++)
|
|
239 { fscanf(m_pFile, "Frame %d: intra %d, quant %d, texture %d, motion %d, total %d\n",
|
|
240 &dummy, &(m_vFrames[i].is_key_frame), &(m_vFrames[i].quant),
|
|
241 &(m_vFrames[i].text_bits), &(m_vFrames[i].motion_bits),
|
|
242 &(m_vFrames[i].total_bits));
|
|
243
|
|
244 m_vFrames[i].total_bits += m_vFrames[i].text_bits*(qual_multiplier-1);
|
|
245 m_vFrames[i].text_bits *= qual_multiplier;
|
|
246 }
|
|
247
|
|
248 if (m_pFile)
|
|
249 { fclose(m_pFile);
|
|
250 m_pFile=NULL;
|
|
251 }
|
|
252
|
|
253 desired_bits=(int64_t)bitrate*(int64_t)iNumFrames/framerate;
|
|
254 non_text_bits=total_bits-text_bits;
|
|
255
|
|
256 if(desired_bits<=non_text_bits)
|
|
257 {
|
|
258 char s[200];
|
|
259 printf("Specified bitrate is too low for this clip.\n"
|
|
260 "Minimum possible bitrate for the clip is %.0f kbps. Overriding\n"
|
|
261 "user-specified value.\n",
|
|
262 (float)(non_text_bits*framerate/(int64_t)iNumFrames));
|
|
263
|
|
264 desired_bits=non_text_bits*3/2;
|
|
265 /*
|
|
266 m_fQuant=max_quantizer;
|
|
267 for(int i=0; i<iNumFrames; i++)
|
|
268 {
|
|
269 m_vFrames[i].drop=0;
|
|
270 m_vFrames[i].mult=1;
|
|
271 }
|
|
272 VbrControl_set_quant(m_fQuant);
|
|
273 return 0;
|
|
274 */
|
|
275 }
|
|
276
|
|
277 desired_bits -= non_text_bits;
|
|
278 /**
|
|
279 BRIEF EXPLANATION OF WHAT'S GOING ON HERE.
|
|
280 We assume that
|
|
281 text_bits=complexity / quantizer
|
|
282 total_bits-text_bits = const(complexity)
|
|
283 where 'complexity' is a characteristic of the frame
|
|
284 and does not depend much on quantizer dynamics.
|
|
285 Using this equation, we calculate 'average' quantizer
|
|
286 to be used for encoding ( 1st order effect ).
|
|
287 Having constant quantizer for the entire stream is not
|
|
288 very convenient - reconstruction errors are
|
|
289 more noticeable in low-motion scenes. To compensate
|
|
290 this effect, we multiply quantizer for each frame by
|
|
291 (complexity/average_complexity)^k,
|
|
292 ( k - parameter of adjustment ). k=0 means 'no compensation'
|
|
293 and k=1 is 'constant bitrate mode'. We choose something in
|
|
294 between, like 0.5 ( 2nd order effect ).
|
|
295 **/
|
|
296
|
|
297 average_complexity=complexity/iNumFrames;
|
|
298
|
|
299 for(i=0; i<iNumFrames; i++)
|
|
300 {
|
|
301 float mult;
|
|
302 if(m_vFrames[i].is_key_frame)
|
|
303 {
|
|
304 if((i+1<iNumFrames) && (m_vFrames[i+1].is_key_frame))
|
|
305 mult=1.25;
|
|
306 else
|
|
307 mult=.75;
|
|
308 }
|
|
309 else
|
|
310 {
|
|
311 mult=m_vFrames[i].text_bits*m_vFrames[i].quant;
|
|
312 mult=(float)sqrt(mult/average_complexity);
|
|
313
|
|
314 // if(i && m_vFrames[i-1].is_key_frame)
|
|
315 // mult *= 0.75;
|
|
316 if(mult<0.5)
|
|
317 mult=0.5;
|
|
318 if(mult>1.5)
|
|
319 mult=1.5;
|
|
320 }
|
|
321
|
|
322 m_vFrames[i].mult=mult;
|
|
323 m_vFrames[i].drop=FALSE;
|
|
324 new_complexity+=m_vFrames[i].text_bits*m_vFrames[i].quant;
|
|
325
|
|
326 denominator+=desired_bits*m_vFrames[i].mult/iNumFrames;
|
|
327 }
|
|
328
|
|
329 m_fQuant=((double)new_complexity)/(double)denominator;
|
|
330
|
|
331 if(m_fQuant<min_quantizer) m_fQuant=min_quantizer;
|
|
332 if(m_fQuant>max_quantizer) m_fQuant=max_quantizer;
|
|
333 m_pFile=fopen("analyse.log", "wb");
|
|
334 if(m_pFile)
|
|
335 {
|
|
336 fprintf(m_pFile, "Total frames: %d Avg quantizer: %f\n",
|
|
337 iNumFrames, m_fQuant);
|
|
338 fprintf(m_pFile, "Expecting %12lld bits\n", desired_bits+non_text_bits);
|
|
339 fflush(m_pFile);
|
|
340 }
|
|
341 VbrControl_set_quant(m_fQuant*m_vFrames[0].mult);
|
|
342 m_lEncodedBits=m_lExpectedBits=0;
|
|
343 return 0;
|
|
344 }
|
|
345
|
|
346 int VbrControl_get_intra()
|
|
347 {
|
|
348 return m_vFrames[m_iCount].is_key_frame;
|
|
349 }
|
|
350
|
|
351 short VbrControl_get_drop()
|
|
352 {
|
|
353 return m_bDrop;
|
|
354 }
|
|
355
|
|
356 int VbrControl_get_quant()
|
|
357 {
|
|
358 return m_iQuant;
|
|
359 }
|
|
360
|
|
361 void VbrControl_set_quant(float quant)
|
|
362 {
|
|
363 m_iQuant=quant;
|
|
364 if((rand() % 10)<((quant-m_iQuant) * 10))
|
|
365 m_iQuant++;
|
|
366 if(m_iQuant<min_quantizer) m_iQuant=min_quantizer;
|
|
367 if(m_iQuant>max_quantizer) m_iQuant=max_quantizer;
|
|
368 }
|
|
369
|
|
370 void VbrControl_update_1pass_vbr()
|
|
371 {
|
|
372 VbrControl_set_quant(m_fQuant);
|
|
373 m_iCount++;
|
|
374 }
|
|
375
|
|
376 void VbrControl_update_2pass_vbr_analysis(int is_key_frame, int motion_bits, int texture_bits, int total_bits, int quant)
|
|
377 {
|
|
378 if(!m_pFile)
|
|
379 return;
|
|
380 fprintf(m_pFile, "Frame %d: intra %d, quant %d, texture %d, motion %d, total %d\n",
|
|
381 m_iCount, is_key_frame, quant, texture_bits, motion_bits, total_bits);
|
|
382 m_iCount++;
|
|
383 }
|
|
384
|
|
385 void VbrControl_update_2pass_vbr_encoding(int motion_bits, int texture_bits, int total_bits)
|
|
386 {
|
|
387 double q;
|
|
388 double dq;
|
|
389
|
|
390 if(m_iCount>=iNumFrames)
|
|
391 return;
|
|
392
|
|
393 m_lExpectedBits+=(m_vFrames[m_iCount].total_bits-m_vFrames[m_iCount].text_bits)
|
|
394 + m_vFrames[m_iCount].text_bits*m_vFrames[m_iCount].quant/m_fQuant;
|
|
395 m_lEncodedBits+=(int64_t)total_bits;
|
|
396
|
|
397 if(m_pFile)
|
|
398 fprintf(m_pFile, "Frame %d: PRESENT, complexity %d, quant multiplier %f, texture %d, total %d ",
|
|
399 m_iCount, m_vFrames[m_iCount].text_bits*m_vFrames[m_iCount].quant,
|
|
400 m_vFrames[m_iCount].mult, texture_bits, total_bits);
|
|
401
|
|
402 m_iCount++;
|
|
403
|
|
404 q = m_fQuant * m_vFrames[m_iCount].mult;
|
|
405 if(q<m_fQuant+min_quant_delta) q=m_fQuant+min_quant_delta;
|
|
406 if(q>m_fQuant+max_quant_delta) q=m_fQuant+max_quant_delta;
|
|
407
|
|
408 dq = (double)m_lEncodedBits/(double)m_lExpectedBits;
|
|
409 dq*=dq;
|
|
410 if(dq<min_rc_quant_delta)
|
|
411 dq=min_rc_quant_delta;
|
|
412 if(dq>max_rc_quant_delta)
|
|
413 dq=max_rc_quant_delta;
|
|
414 if(m_iCount<20) // no framerate corrections in first frames
|
|
415 dq=1;
|
|
416 if(m_pFile)
|
|
417 fprintf(m_pFile, "Progress: expected %12lld, achieved %12lld, dq %f",
|
|
418 m_lExpectedBits, m_lEncodedBits, dq);
|
|
419 q *= dq;
|
|
420 VbrControl_set_quant(q);
|
|
421 if(m_pFile)
|
|
422 fprintf(m_pFile, ", new quant %d\n", m_iQuant);
|
|
423 }
|
|
424
|
|
425 void VbrControl_close()
|
|
426 {
|
|
427 if(m_pFile)
|
|
428 {
|
|
429 fclose(m_pFile);
|
|
430 m_pFile=NULL;
|
|
431 }
|
|
432 free(m_vFrames);
|
|
433 }
|