← Back to branch summary

~ubuntu-branches/ubuntu/feisty/avidemux/feisty

« back to all changes in this revision

Viewing changes to avidemux/ADM_encoder/adm_encx264.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Daniel T Chen
  • Date: 2006-12-15 17:13:20 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20061215171320-w79pvpehxx2fr217
Tags: 1:2.3.0-0.0ubuntu1
* Merge from debian-multimedia.org, remaining Ubuntu change:
  - desktop file,
  - no support for ccache and make -j.
* Closes Ubuntu: #69614.

Show diffs side-by-side

added added

removed removed

Lines of Context:
avidemux/ADM_encoder/adm_encx264.cpp
19
19
 ***************************************************************************/
20
20
#include "config.h"
21
21
#ifdef USE_X264
22
 
 
 
22
 
23
23
#include <stdio.h>
24
24
#include <stdlib.h>
25
25
 
38
38
 
39
39
#include "ADM_encoder/adm_encoder.h"
40
40
#include "ADM_encoder/adm_encx264.h"
 
41
#include "ADM_toolkit/ADM_cpuCap.h"
41
42
 
42
43
 
43
44
#define aprintf printf
44
45
 
45
46
 
46
47
/*_________________________________________________*/
47
 
EncoderX264::EncoderX264 (COMPRES_PARAMS  *codecconfig)
 
48
EncoderX264::EncoderX264 (COMPRES_PARAMS * codecconfig)
48
49
{
49
50
 
50
 
  _codec = NULL;  
 
51
  _codec = NULL;
51
52
  strcpy (_logname, "");
52
53
  _frametogo = 0;
53
 
  _pass1Done=0;
54
 
  memcpy(&_param,codecconfig,sizeof(_param));
55
 
  ADM_assert(codecconfig->extraSettingsLen==sizeof(_codecParam));
56
 
  memcpy(&_codecParam,(codecconfig->extraSettings),sizeof(_codecParam));
57
 
 
 
54
  _pass1Done = 0;
 
55
  memcpy (&_param, codecconfig, sizeof (_param));
 
56
  ADM_assert (codecconfig->extraSettingsLen == sizeof (_codecParam));
 
57
  memcpy (&_codecParam, (codecconfig->extraSettings), sizeof (_codecParam));
 
58
  _codecParam.nbThreads = ADM_useNbThreads ();
 
59
  _logfile = NULL;
58
60
 
59
61
};
60
62
EncoderX264::~EncoderX264 ()
61
63
{
62
64
 
63
 
  stop();
 
65
  stop ();
64
66
 
65
67
};
 
68
uint8_t
 
69
EncoderX264::hasExtraHeaderData (uint32_t * l, uint8_t ** data)
 
70
{
 
71
  uint8_t r = 0;
 
72
  r = _codec->getExtraData (l, data);
 
73
  printf ("x264 has %d extra bytes\n", *l);
 
74
  return r;
 
75
 
 
76
}
66
77
//--------------------------------
67
 
uint8_t         EncoderX264::configure (AVDMGenericVideoStream * instream)
 
78
uint8_t
 
79
EncoderX264::configure (AVDMGenericVideoStream * instream)
68
80
{
69
81
  ADM_assert (instream);
70
82
  ADV_Info *info;
73
85
  _w = info->width;
74
86
  _h = info->height;
75
87
 
76
 
  _vbuffer=new ADMImage(_w,_h);
 
88
  _vbuffer = new ADMImage (_w, _h);
77
89
  ADM_assert (_vbuffer);
78
90
  _in = instream;
79
 
  _fps1000=info->fps1000;
80
 
    switch (_param.mode)
81
 
      {
82
 
      
83
 
      case COMPRESS_CQ:
84
 
                  printf("\n X264 cq mode: %ld",_param.qz);
85
 
                  _state = enc_CQ;
86
 
                  _codec = new   X264EncoderCQ (_w, _h);
87
 
  
88
 
                if(!_codec->init(_param.qz,info->fps1000,&_codecParam))
89
 
                  {
90
 
                          printf("Error initi X264 CQ mode\n");
91
 
                          return 0;
92
 
                  }
93
 
                  break;
94
 
      case COMPRESS_CBR:
95
 
                  printf("\n X264 cbr mode: %lu",_param.bitrate);
96
 
                  _state = enc_CBR;
97
 
  
98
 
                  _codec = new X264EncoderCBR (_w, _h);
99
 
                  if(!_codec->init(_param.bitrate,info->fps1000,&_codecParam))
100
 
                  {
101
 
                    printf("Error initi X264 CBR mode\n");
102
 
                          return 0;
103
 
                  }
104
 
                  break;
105
 
     case COMPRESS_2PASS:
106
 
               // printf("\n X264 dual size: %lu (%s)\n",_param.finalsize,_logname);
107
 
                _state = enc_Pass1;
108
 
                _codec = new X264EncoderPass2 (_w, _h);
109
 
                  //strcpy(encparam.logName,_logname);
110
 
                  //printf("Using %s as stat file\n",encparam.logName);
111
 
                        
112
 
                  break;                  
113
 
        default:
114
 
                  ADM_assert(0);
115
 
      }
116
 
    
 
91
  _fps1000 = info->fps1000;
 
92
  switch (_param.mode)
 
93
    {
 
94
 
 
95
    case COMPRESS_CQ:
 
96
      printf ("\n X264 cq mode: %ld", _param.qz);
 
97
      _state = enc_CQ;
 
98
      _codec = new X264EncoderCQ (_w, _h);
 
99
 
 
100
      if (!_codec->init (_param.qz, info->fps1000, &_codecParam))
 
101
        {
 
102
          printf ("Error initi X264 CQ mode\n");
 
103
          return 0;
 
104
        }
 
105
      break;
 
106
    case COMPRESS_AQ:
 
107
      printf ("\n X264 AQ mode: %ld", _param.qz);
 
108
      _state = enc_CQ;
 
109
      _codec = new X264EncoderAQ (_w, _h);
 
110
 
 
111
      if (!_codec->init (_param.qz, info->fps1000, &_codecParam))
 
112
        {
 
113
          printf ("Error initi X264 AQ mode\n");
 
114
          return 0;
 
115
        }
 
116
      break;
 
117
    case COMPRESS_CBR:
 
118
      printf ("\n X264 cbr mode: %lu", _param.bitrate);
 
119
      _state = enc_CBR;
 
120
 
 
121
      _codec = new X264EncoderCBR (_w, _h);
 
122
      if (!_codec->init (_param.bitrate, info->fps1000, &_codecParam))
 
123
        {
 
124
          printf ("Error initi X264 CBR mode\n");
 
125
          return 0;
 
126
        }
 
127
      break;
 
128
    case COMPRESS_2PASS:
 
129
    case COMPRESS_2PASS_BITRATE:
 
130
      // printf("\n X264 dual size: %lu (%s)\n",_param.finalsize,_logname);
 
131
      _state = enc_Pass1;
 
132
      _codec = new X264EncoderPass1 (_w, _h);
 
133
      _codecParam.logfile = _logfile;
 
134
      //strcpy(encparam.logName,_logname);
 
135
      //printf("Using %s as stat file\n",encparam.logName);
 
136
 
 
137
      break;
 
138
    default:
 
139
      ADM_assert (0);
 
140
    }
 
141
 
117
142
 
118
143
  printf ("\n X264 Encoder ready , w: %lu h:%lu mode:%d", _w, _h, _state);
119
144
  return 1;
122
147
 
123
148
 
124
149
 
125
 
uint8_t    EncoderX264::startPass1 (void)
 
150
uint8_t
 
151
EncoderX264::startPass1 (void)
126
152
{
127
153
  ADV_Info *info;
128
154
  ADM_assert (_state == enc_Pass1);
129
 
  info= _in->getInfo ();
130
 
  if(!_codec->init(_param.bitrate,info->fps1000,&(_codecParam)))
131
 
  {
132
 
    printf("Error initi Xvid4 pass1 mode\n");
133
 
    return 0;
134
 
  }
 
155
  info = _in->getInfo ();
 
156
  if (!_codec->init (_param.bitrate, info->fps1000, &(_codecParam)))
 
157
    {
 
158
      printf ("Error initi Xvid4 pass1 mode\n");
 
159
      return 0;
 
160
    }
135
161
  return 1;
136
162
}
137
163
 
138
164
 
139
165
 
140
 
uint8_t    EncoderX264::isDualPass (void)
 
166
uint8_t
 
167
EncoderX264::isDualPass (void)
141
168
{
142
 
 
 
169
 
143
170
  if ((_state == enc_Pass1) || (_state == enc_Pass2))
144
 
  {
145
 
    return 1;
146
 
  }
 
171
    {
 
172
      return 1;
 
173
    }
147
174
  return 0;
148
175
 
149
176
}
150
177
 
151
 
uint8_t    EncoderX264::setLogFile (const char *lofile, uint32_t nbframe)
 
178
uint8_t
 
179
EncoderX264::setLogFile (const char *lofile, uint32_t nbframe)
152
180
{
153
 
 // strcpy (_logname, lofile);
 
181
  // strcpy (_logname, lofile);
 
182
  _logfile = ADM_strdup (lofile);
 
183
  printf ("Enc X264, using %s as logfile\n", _logfile);
154
184
  _frametogo = nbframe;
155
 
  _totalframe= nbframe;
 
185
  _totalframe = nbframe;
156
186
  return 1;
157
187
 
158
188
}
159
 
 
160
189
//______________________________
161
190
uint8_t
162
 
    EncoderX264::encode (uint32_t frame, uint32_t * len, uint8_t * out,
163
 
                          uint32_t * flags)
 
191
        EncoderX264::encode (uint32_t frame, ADMBitstream *out)
164
192
{
165
 
  uint32_t l, f,q;
 
193
  uint32_t l, f, q;
 
194
  uint8_t r = 0;
166
195
  //ENC_RESULT enc;
167
196
 
168
197
  ADM_assert (_codec);
169
198
  ADM_assert (_in);
170
199
 
171
200
  if (!_in->getFrameNumberNoAlloc (frame, &l, _vbuffer, &f))
172
 
  {
173
 
    printf ("\n Error : Cannot read incoming frame !");
174
 
    return 0;
175
 
  }
 
201
    {
 
202
      printf ("\n Error : Cannot read incoming frame !");
 
203
      return 0;
 
204
    }
176
205
 
177
 
   //   return _codec->encode (_vbuffer, out, len, flags);
 
206
  //   return _codec->encode (_vbuffer, out, len, flags);
178
207
  switch (_state)
179
 
  {
180
 
   
181
 
                        
 
208
    {
 
209
 
 
210
 
182
211
    case enc_CBR:
183
212
    case enc_CQ:
184
213
    case enc_Pass1:
185
214
    case enc_Pass2:
186
 
      return _codec->encode (_vbuffer, out, len, flags);
 
215
      r = _codec->encode (_vbuffer, out );
 
216
      return r;
187
217
      break;
188
 
  
 
218
 
189
219
    default:
190
220
      ADM_assert (0);
191
 
  }
192
 
  return 1;   
193
 
 
194
 
 
 
221
    }
 
222
  return 1;
 
223
 
 
224
 
195
225
}
196
226
 
197
227
//_______________________________
198
 
uint8_t
199
 
    EncoderX264::stop (void)
 
228
uint8_t EncoderX264::stop (void)
200
229
{
201
 
  if(_codec)        delete       _codec;
 
230
  if (_codec)
 
231
    delete
 
232
      _codec;
202
233
  _codec = NULL;
203
 
                
 
234
  if (_logfile)
 
235
    delete[]_logfile;
 
236
 
204
237
 
205
238
  return 1;
206
239
 
207
240
}
208
 
uint8_t
209
 
    EncoderX264::startPass2 (void)
 
241
uint32_t ADM_computeBitrate(uint32_t fps1000, uint32_t nbFrame, uint32_t sizeInMB);
 
242
uint8_t EncoderX264::startPass2 (void)
210
243
{
211
 
  float br;
212
 
  uint32_t finalSize;
213
244
  
 
245
  uint32_t    bitrate;
 
246
 
214
247
  ADM_assert (_state == enc_Pass1);
215
 
  printf ("\n Starting pass 2 (%dx%d)\n",_w,_h);
216
 
  
217
 
  
218
 
  finalSize=_param.finalsize;
219
 
   
220
 
 
221
 
   
222
 
  br=finalSize*8;
223
 
  br*=1024*1024;
224
 
  br=br/ _totalframe;                             // bit / frame
225
 
  br=br*_fps1000;
226
 
  br=br/1000;
227
 
   
228
 
  finalSize= (int)floor(br);
229
 
            
 
248
  printf ("\n Starting pass 2 (%dx%d)\n", _w, _h);
 
249
 
 
250
 
 
251
  
 
252
 
 
253
  if(_param.mode==COMPRESS_2PASS)
 
254
  {
 
255
      bitrate=ADM_computeBitrate(_fps1000, _totalframe, _param.finalsize);
 
256
      printf("[x264] Size %u, average bitrate %u kb/s\n",_param.finalsize,bitrate);
 
257
  }else if(_param.mode==COMPRESS_2PASS_BITRATE)
 
258
  {
 
259
      bitrate=_param.avg_bitrate*1000;
 
260
      printf("[x264] Average bitrate %u kb/s\n",bitrate);
 
261
  }else ADM_assert(0);
 
262
 
230
263
  _state = enc_Pass2;
231
 
        // Delete codec and start new one
 
264
  // Delete codec and start new one
232
265
  if (_codec)
233
 
  {
234
 
    delete  _codec;
235
 
    _codec = NULL;
236
 
  }
237
 
  printf("\n X264 dual size: %lu MB\n",_param.finalsize);
238
 
        
 
266
    {
 
267
      delete
 
268
        _codec;
 
269
      _codec = NULL;
 
270
    }
 
271
  printf ("\n X264 dual size: %lu MB\n", _param.finalsize);
 
272
 
239
273
  _codec = new X264EncoderPass2 (_w, _h);
240
 
 // strcpy(encparam.logName,_logname);
 
274
  // strcpy(encparam.logName,_logname);
241
275
  //printf("Using %s as stat file, average bitrate %d kbps\n",_logname,finalSize/1000);
242
 
  if(!_codec->init((uint32_t )br,_fps1000,&_codecParam))
243
 
  {
244
 
    printf("Error initializing x264 pass1 mode\n");
245
 
    return 0;
246
 
  }
247
 
  _frametogo=0;
 
276
  if (!_codec->init (bitrate, _fps1000, &_codecParam))
 
277
    {
 
278
      printf ("Error initializing x264 pass1 mode\n");
 
279
      return 0;
 
280
    }
 
281
  _frametogo = 0;
248
282
  return 1;
249
283
}
250
 
 
251
284
#endif
252
 
 
253
 
 
254
 
 
255