← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

« back to all changes in this revision

Viewing changes to ffmpeg/libpostproc/postprocess_internal.h

  • Committer: Bazaar Package Importer
  • Author(s): Lionel Le Folgoc, Andrew Starr-Bochicchio, Lionel Le Folgoc
  • Date: 2008-12-26 00:10:06 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20081226001006-2040ls9680bd1blt
Tags: 1.1.7-0.2ubuntu1
https://launchpad.net/bugs/298547
https://launchpad.net/bugs/311412
[ Andrew Starr-Bochicchio ]
* Merge from debian-multimedia (LP: #298547), Ubuntu Changes:
 - For ffmpeg-related build-deps, fix versionized dependencies
   as the ubuntu versioning is different than debian-multimedia's.

[ Lionel Le Folgoc ]
* LP: #311412 is fixed since the 1.1.7~rc1-0.1 revision.
* debian/patches/03_ffmpeg.diff: updated to fix FTBFS due to libswscale API
  change (cherry-pick from Gentoo #234383).

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libpostproc/postprocess_internal.h
23
23
 * internal api header.
24
24
 */
25
25
 
 
26
#ifndef FFMPEG_POSTPROCESS_INTERNAL_H
 
27
#define FFMPEG_POSTPROCESS_INTERNAL_H
 
28
 
26
29
#include "avutil.h"
 
30
#include "postprocess.h"
27
31
 
28
32
#define V_DEBLOCK       0x01
29
33
#define H_DEBLOCK       0x02
51
55
#define FULL_Y_RANGE    0x8000                  // 32768
52
56
 
53
57
//Deinterlacing Filters
54
 
#define        LINEAR_IPOL_DEINT_FILTER         0x10000 // 65536
55
 
#define        LINEAR_BLEND_DEINT_FILTER        0x20000 // 131072
56
 
#define        CUBIC_BLEND_DEINT_FILTER         0x8000  // (not implemented yet)
57
 
#define        CUBIC_IPOL_DEINT_FILTER          0x40000 // 262144
58
 
#define        MEDIAN_DEINT_FILTER              0x80000 // 524288
59
 
#define        FFMPEG_DEINT_FILTER              0x400000
60
 
#define        LOWPASS5_DEINT_FILTER            0x800000
 
58
#define LINEAR_IPOL_DEINT_FILTER        0x10000 // 65536
 
59
#define LINEAR_BLEND_DEINT_FILTER       0x20000 // 131072
 
60
#define CUBIC_BLEND_DEINT_FILTER        0x8000  // (not implemented yet)
 
61
#define CUBIC_IPOL_DEINT_FILTER         0x40000 // 262144
 
62
#define MEDIAN_DEINT_FILTER             0x80000 // 524288
 
63
#define FFMPEG_DEINT_FILTER             0x400000
 
64
#define LOWPASS5_DEINT_FILTER           0x800000
61
65
 
62
66
#define TEMP_NOISE_FILTER               0x100000
63
67
#define FORCE_QUANT                     0x200000
64
68
 
65
 
#if ( defined(__PIC__) || defined(__pic__) ) && ! defined(PIC)
66
 
#    define PIC
67
 
#endif
68
 
 
69
 
//use if u want a faster postprocessing code
70
 
//cant differentiate between chroma & luma filters (both on or both off)
71
 
//obviosly the -pp option at the commandline has no effect except turning the here selected
 
69
//use if you want a faster postprocessing code
 
70
//cannot differentiate between chroma & luma filters (both on or both off)
 
71
//obviously the -pp option on the command line has no effect except turning the here selected
72
72
//filters on
73
73
//#define COMPILE_TIME_MODE 0x77
74
74
 
75
 
#if 1
76
75
static inline int CLIP(int a){
77
 
        if(a&256) return ((a)>>31)^(-1);
78
 
        else      return a;
 
76
    if(a&256) return ((a)>>31)^(-1);
 
77
    else      return a;
79
78
}
80
 
//#define CLIP(a) (((a)&256) ? ((a)>>31)^(-1) : (a))
81
 
#elif 0
82
 
#define CLIP(a) clip_tab[a]
83
 
#else
84
 
#define CLIP(a) (a)
85
 
#endif
86
79
/**
87
80
 * Postprocessng filter.
88
81
 */
89
82
struct PPFilter{
90
 
        const char *shortName;
91
 
        const char *longName;
92
 
        int chromDefault;       ///< is chrominance filtering on by default if this filter is manually activated
93
 
        int minLumQuality;      ///< minimum quality to turn luminance filtering on
94
 
        int minChromQuality;    ///< minimum quality to turn chrominance filtering on
95
 
        int mask;               ///< Bitmask to turn this filter on
 
83
    const char *shortName;
 
84
    const char *longName;
 
85
    int chromDefault;       ///< is chrominance filtering on by default if this filter is manually activated
 
86
    int minLumQuality;      ///< minimum quality to turn luminance filtering on
 
87
    int minChromQuality;    ///< minimum quality to turn chrominance filtering on
 
88
    int mask;               ///< Bitmask to turn this filter on
96
89
};
97
90
 
98
91
/**
99
92
 * Postprocessng mode.
100
93
 */
101
94
typedef struct PPMode{
102
 
        int lumMode;                    ///< acivates filters for luminance
103
 
        int chromMode;                  ///< acivates filters for chrominance
104
 
        int error;                      ///< non zero on error
105
 
 
106
 
        int minAllowedY;                ///< for brigtness correction
107
 
        int maxAllowedY;                ///< for brihtness correction
108
 
        float maxClippedThreshold;      ///< amount of "black" u r willing to loose to get a brightness corrected picture
109
 
 
110
 
        int maxTmpNoise[3];             ///< for Temporal Noise Reducing filter (Maximal sum of abs differences)
111
 
 
112
 
        int baseDcDiff;
113
 
        int flatnessThreshold;
114
 
 
115
 
        int forcedQuant;                ///< quantizer if FORCE_QUANT is used
 
95
    int lumMode;                    ///< acivates filters for luminance
 
96
    int chromMode;                  ///< acivates filters for chrominance
 
97
    int error;                      ///< non zero on error
 
98
 
 
99
    int minAllowedY;                ///< for brigtness correction
 
100
    int maxAllowedY;                ///< for brihtness correction
 
101
    float maxClippedThreshold;      ///< amount of "black" u r willing to loose to get a brightness corrected picture
 
102
 
 
103
    int maxTmpNoise[3];             ///< for Temporal Noise Reducing filter (Maximal sum of abs differences)
 
104
 
 
105
    int baseDcDiff;
 
106
    int flatnessThreshold;
 
107
 
 
108
    int forcedQuant;                ///< quantizer if FORCE_QUANT is used
116
109
} PPMode;
117
110
 
118
111
/**
119
112
 * postprocess context.
120
113
 */
121
114
typedef struct PPContext{
122
 
        /**
123
 
         * info on struct for av_log
124
 
         */
125
 
        AVClass *av_class;
126
 
 
127
 
        uint8_t *tempBlocks; ///<used for the horizontal code
128
 
 
129
 
        /**
130
 
         * luma histogram.
131
 
         * we need 64bit here otherwise we'll going to have a problem
132
 
         * after watching a black picture for 5 hours
133
 
         */
134
 
        uint64_t *yHistogram;
135
 
 
136
 
        DECLARE_ALIGNED(8, uint64_t, packedYOffset);
137
 
        DECLARE_ALIGNED(8, uint64_t, packedYScale);
138
 
 
139
 
        /** Temporal noise reducing buffers */
140
 
        uint8_t *tempBlured[3];
141
 
        int32_t *tempBluredPast[3];
142
 
 
143
 
        /** Temporary buffers for handling the last row(s) */
144
 
        uint8_t *tempDst;
145
 
        uint8_t *tempSrc;
146
 
 
147
 
        uint8_t *deintTemp;
148
 
 
149
 
        DECLARE_ALIGNED(8, uint64_t, pQPb);
150
 
        DECLARE_ALIGNED(8, uint64_t, pQPb2);
151
 
 
152
 
        DECLARE_ALIGNED(8, uint64_t, mmxDcOffset[64]);
153
 
        DECLARE_ALIGNED(8, uint64_t, mmxDcThreshold[64]);
154
 
 
155
 
        QP_STORE_T *stdQPTable;       ///< used to fix MPEG2 style qscale
156
 
        QP_STORE_T *nonBQPTable;
157
 
        QP_STORE_T *forcedQPTable;
158
 
 
159
 
        int QP;
160
 
        int nonBQP;
161
 
 
162
 
        int frameNum;
163
 
 
164
 
        int cpuCaps;
165
 
 
166
 
        int qpStride; ///<size of qp buffers (needed to realloc them if needed)
167
 
        int stride;   ///<size of some buffers (needed to realloc them if needed)
168
 
 
169
 
        int hChromaSubSample;
170
 
        int vChromaSubSample;
171
 
 
172
 
        PPMode ppMode;
 
115
    /**
 
116
     * info on struct for av_log
 
117
     */
 
118
    const AVClass *av_class;
 
119
 
 
120
    uint8_t *tempBlocks; ///<used for the horizontal code
 
121
 
 
122
    /**
 
123
     * luma histogram.
 
124
     * we need 64bit here otherwise we'll going to have a problem
 
125
     * after watching a black picture for 5 hours
 
126
     */
 
127
    uint64_t *yHistogram;
 
128
 
 
129
    DECLARE_ALIGNED(8, uint64_t, packedYOffset);
 
130
    DECLARE_ALIGNED(8, uint64_t, packedYScale);
 
131
 
 
132
    /** Temporal noise reducing buffers */
 
133
    uint8_t *tempBlurred[3];
 
134
    int32_t *tempBlurredPast[3];
 
135
 
 
136
    /** Temporary buffers for handling the last row(s) */
 
137
    uint8_t *tempDst;
 
138
    uint8_t *tempSrc;
 
139
 
 
140
    uint8_t *deintTemp;
 
141
 
 
142
    DECLARE_ALIGNED(8, uint64_t, pQPb);
 
143
    DECLARE_ALIGNED(8, uint64_t, pQPb2);
 
144
 
 
145
    DECLARE_ALIGNED(8, uint64_t, mmxDcOffset[64]);
 
146
    DECLARE_ALIGNED(8, uint64_t, mmxDcThreshold[64]);
 
147
 
 
148
    QP_STORE_T *stdQPTable;       ///< used to fix MPEG2 style qscale
 
149
    QP_STORE_T *nonBQPTable;
 
150
    QP_STORE_T *forcedQPTable;
 
151
 
 
152
    int QP;
 
153
    int nonBQP;
 
154
 
 
155
    int frameNum;
 
156
 
 
157
    int cpuCaps;
 
158
 
 
159
    int qpStride; ///<size of qp buffers (needed to realloc them if needed)
 
160
    int stride;   ///<size of some buffers (needed to realloc them if needed)
 
161
 
 
162
    int hChromaSubSample;
 
163
    int vChromaSubSample;
 
164
 
 
165
    PPMode ppMode;
173
166
} PPContext;
174
167
 
175
168
 
176
 
static inline void linecpy(void *dest, void *src, int lines, int stride)
177
 
{
178
 
        if (stride > 0) {
179
 
                memcpy(dest, src, lines*stride);
180
 
        } else {
181
 
                memcpy(dest+(lines-1)*stride, src+(lines-1)*stride, -lines*stride);
182
 
        }
 
169
static inline void linecpy(void *dest, const void *src, int lines, int stride) {
 
170
    if (stride > 0) {
 
171
        memcpy(dest, src, lines*stride);
 
172
    } else {
 
173
        memcpy((uint8_t*)dest+(lines-1)*stride, (const uint8_t*)src+(lines-1)*stride, -lines*stride);
 
174
    }
183
175
}
 
176
 
 
177
#endif /* FFMPEG_POSTPROCESS_INTERNAL_H */