← Back to branch summary

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

« back to all changes in this revision

Viewing changes to avidemux/ADM_codecs/ADM_xvid4.h

  • 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_codecs/ADM_xvid4.h
16
16
 *                                                                         *
17
17
 ***************************************************************************/
18
18
 
19
 
 #ifdef USE_XVID_4
20
 
 
21
 
 
22
 
 
23
 
 #include "ADM_codecs/ADM_xvid4param.h"
24
 
 
25
 
 class xvid4Encoder     : public encoder
26
 
        {
27
 
        protected :
28
 
                        
29
 
                        uint8_t         _init;
30
 
                        void            *_handle;
31
 
                        uint32_t        encode_flags;
32
 
                        uint32_t        motion_flags;
33
 
                        uint32_t        _fps1000;
34
 
                        xvid4EncParam   _param;    
35
 
                        void            dumpConf(void);
36
 
                        void            checkFlags( xvid4EncParam *extend=NULL ); 
37
 
                        void            encUpdate( void );   
38
 
                        void            createUpdate( void );  
39
 
                        
40
 
                        uint8_t         preAmble(uint8_t *in );
41
 
                        uint8_t         postAmble(uint32_t *flags ) ;
42
 
                        void            dump(void);
43
 
 
44
 
          public :
45
 
                                        xvid4Encoder(uint32_t width,uint32_t height)   : encoder(width,height)
46
 
                                        {
47
 
                                                _init=0;   
48
 
                                                _handle=NULL;                             
49
 
                                        } ;
50
 
                                        ~xvid4Encoder();
51
 
                                        void            *getXvidStat( void );                           
52
 
                                        uint8_t         stopEncoder(void );
53
 
                                virtual uint8_t         init( uint32_t val,uint32_t fps1000,xvid4EncParam *param );
54
 
                                
55
 
                                        uint8_t         init(uint32_t a, uint32_t b) {return 0;} // not used
56
 
                                        uint8_t         getResult( void *ress);                
57
 
                                virtual uint8_t         encode( ADMImage        *in,
58
 
                                                                uint8_t         *out,
59
 
                                                                uint32_t        *len,
60
 
                                                                uint32_t        *flags)=0;
61
 
                                
62
 
 
63
 
   };
64
 
 
65
 
   class xvid4EncoderCQ : public    xvid4Encoder
66
 
  {
67
 
        protected :
68
 
                                
69
 
                        uint32_t _q;              
70
 
        
71
 
          public :
72
 
                        xvid4EncoderCQ(uint32_t width,uint32_t height) : xvid4Encoder(width,height)
73
 
                                        {
74
 
 
75
 
                                        } ;
76
 
                        
77
 
                        virtual         uint8_t init( uint32_t val,uint32_t fps1000,xvid4EncParam *param );     
78
 
                        virtual         uint8_t encode(
79
 
                                                ADMImage        *in,
80
 
                                                uint8_t         *out,
81
 
                                                uint32_t        *len,
82
 
                                                uint32_t        *flags);
83
 
   };
84
 
      class xvid4EncoderVBRExternal : public    xvid4Encoder
85
 
  {
86
 
        protected :
87
 
                                
88
 
                        uint32_t _q;              
89
 
        
90
 
          public :
91
 
                        xvid4EncoderVBRExternal(uint32_t width,uint32_t height) : xvid4Encoder(width,height)
92
 
                                        {
93
 
 
94
 
                                        } ;
95
 
                        
96
 
                        virtual         uint8_t init( uint32_t val,uint32_t fps1000,xvid4EncParam *param );     
97
 
                        virtual         uint8_t encode(
98
 
                                                ADMImage        *in,
99
 
                                                uint8_t         *out,
100
 
                                                uint32_t        *len,
101
 
                                                uint32_t        *flags);
102
 
                                        uint8_t encodeVBR(
103
 
                                                ADMImage        *in,
104
 
                                                uint8_t         *out,
105
 
                                                uint32_t        *len,
106
 
                                                uint32_t        quant,
107
 
                                                uint32_t        *flags);
108
 
   };
109
 
   class xvid4EncoderCBR : public    xvid4Encoder
110
 
  {
111
 
        protected :
112
 
                                
113
 
                        uint32_t _bitrate;     // In kBits!         
114
 
        
115
 
          public :
116
 
                        xvid4EncoderCBR(uint32_t width,uint32_t height) : xvid4Encoder(width,height)
117
 
                                        {
118
 
 
119
 
                                        } ;
120
 
                        
121
 
                        virtual         uint8_t init( uint32_t val,uint32_t fps1000,xvid4EncParam *param );     
122
 
                        virtual         uint8_t encode(
123
 
                                                ADMImage        *in,
124
 
                                                uint8_t         *out,
125
 
                                                uint32_t        *len,
126
 
                                                uint32_t        *flags);
127
 
   };
128
 
   class xvid4EncoderPass1 : public    xvid4Encoder
129
 
  {
130
 
        protected :
131
 
                                
132
 
                                  
133
 
        
134
 
          public :
135
 
                        xvid4EncoderPass1(uint32_t width,uint32_t height) : xvid4Encoder(width,height)
136
 
                                        {
137
 
 
138
 
                                        } ;
139
 
                        
140
 
                        virtual         uint8_t init( uint32_t val,uint32_t fps1000,xvid4EncParam *param );     
141
 
                        virtual         uint8_t encode(
142
 
                                                ADMImage        *in,
143
 
                                                uint8_t         *out,
144
 
                                                uint32_t        *len,
145
 
                                                uint32_t        *flags);
146
 
   };
147
 
 class xvid4EncoderPass2 : public    xvid4Encoder
148
 
  {
149
 
        protected :
150
 
                                
151
 
                        uint32_t _bitrate;              
152
 
        
153
 
          public :
154
 
                        xvid4EncoderPass2(uint32_t width,uint32_t height) : xvid4Encoder(width,height)
155
 
                                        {
156
 
 
157
 
                                        } ;
158
 
                        
159
 
                        virtual         uint8_t init( uint32_t val,uint32_t fps1000,xvid4EncParam *param );     
160
 
                        virtual         uint8_t encode(
161
 
                                                ADMImage        *in,
162
 
                                                uint8_t         *out,
163
 
                                                uint32_t        *len,
164
 
                                                uint32_t        *flags);
165
 
   };
166
 
 
167
 
   
168
 
 #endif
169
 
 
 
19
#ifdef USE_XVID_4
 
20
 
 
21
 
 
22
 
 
23
#include "ADM_codecs/ADM_xvid4param.h"
 
24
 
 
25
class xvid4Encoder:public encoder
 
26
{
 
27
protected:uint8_t _init;
 
28
  void *_handle;
 
29
  uint32_t encode_flags;
 
30
  uint32_t motion_flags;
 
31
  uint32_t _fps1000;
 
32
  xvid4EncParam _param;
 
33
  void dumpConf (void);
 
34
  void checkFlags (xvid4EncParam * extend = NULL);
 
35
  void createUpdate (void);
 
36
 
 
37
  uint8_t preAmble (uint8_t * in);
 
38
  uint8_t postAmble (ADMBitstream * out);
 
39
  void dump (void);
 
40
 
 
41
public:  xvid4Encoder (uint32_t width, uint32_t height):encoder (width,
 
42
                                                            height)
 
43
  {
 
44
    _init = 0;
 
45
    _handle = NULL;
 
46
  };
 
47
  ~xvid4Encoder ();
 
48
  void *getXvidStat (void);
 
49
  uint8_t stopEncoder (void);
 
50
  virtual uint8_t init (uint32_t val, uint32_t fps1000,
 
51
                        xvid4EncParam * param);
 
52
 
 
53
  uint8_t init (uint32_t a, uint32_t b)
 
54
  {
 
55
    return 0;
 
56
  }                             // not used
 
57
  virtual uint8_t encode (ADMImage * in, ADMBitstream * out) ;
 
58
};
 
59
 
 
60
class xvid4EncoderCQ:public xvid4Encoder
 
61
{
 
62
protected:uint32_t _q;
 
63
 
 
64
public:xvid4EncoderCQ (uint32_t width, uint32_t height):xvid4Encoder (width,
 
65
                                                                 height)
 
66
  {
 
67
 
 
68
  };
 
69
 
 
70
  virtual uint8_t init (uint32_t val, uint32_t fps1000,
 
71
                        xvid4EncParam * param);
 
72
  virtual uint8_t encode (ADMImage * in, ADMBitstream * out);
 
73
};
 
74
class xvid4EncoderVBRExternal:public xvid4Encoder
 
75
{
 
76
protected:uint32_t _q;
 
77
 
 
78
public:xvid4EncoderVBRExternal (uint32_t width,
 
79
                           uint32_t height):xvid4Encoder (width,
 
80
                                                          height)
 
81
  {
 
82
 
 
83
  };
 
84
 
 
85
  virtual uint8_t init (uint32_t val, uint32_t fps1000,
 
86
                        xvid4EncParam * param);
 
87
  virtual uint8_t encode (ADMImage * in, ADMBitstream * out);
 
88
  
 
89
};
 
90
class xvid4EncoderCBR:public xvid4Encoder
 
91
{
 
92
protected:uint32_t _bitrate;    // In kBits!         
 
93
 
 
94
public:xvid4EncoderCBR (uint32_t width,
 
95
                   uint32_t height):xvid4Encoder (width, height)
 
96
  {
 
97
 
 
98
  };
 
99
 
 
100
  virtual uint8_t init (uint32_t val, uint32_t fps1000,
 
101
                        xvid4EncParam * param);
 
102
  virtual uint8_t encode (ADMImage * in, ADMBitstream * out);
 
103
};
 
104
class xvid4EncoderPass1:public xvid4Encoder
 
105
{
 
106
protected: public:xvid4EncoderPass1 (uint32_t width,
 
107
                     uint32_t height):xvid4Encoder (width,
 
108
                                                    height)
 
109
  {
 
110
 
 
111
  };
 
112
 
 
113
  virtual uint8_t init (uint32_t val, uint32_t fps1000,
 
114
                        xvid4EncParam * param);
 
115
  
 
116
};
 
117
class xvid4EncoderPass2:public xvid4Encoder
 
118
{
 
119
protected:uint32_t _bitrate;
 
120
 
 
121
public:xvid4EncoderPass2 (uint32_t width,
 
122
                     uint32_t height):xvid4Encoder (width, height)
 
123
  {
 
124
 
 
125
  };
 
126
 
 
127
  virtual uint8_t init (uint32_t val, uint32_t fps1000,
 
128
                        xvid4EncParam * param);
 
129
  
 
130
};
 
131
 
 
132
 
 
133
#endif