← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/raw.c

  • 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/libavcodec/raw.c
25
25
 */
26
26
 
27
27
#include "avcodec.h"
28
 
 
29
 
typedef struct RawVideoContext {
30
 
    unsigned char * buffer;  /* block of memory for holding one frame */
31
 
    int             length;  /* number of bytes in buffer */
32
 
    AVFrame pic;             ///< AVCodecContext.coded_frame
33
 
} RawVideoContext;
34
 
 
35
 
typedef struct PixelFormatTag {
36
 
    int pix_fmt;
37
 
    unsigned int fourcc;
38
 
} PixelFormatTag;
39
 
 
40
 
static const PixelFormatTag pixelFormatTags[] = {
 
28
#include "raw.h"
 
29
 
 
30
const PixelFormatTag ff_raw_pixelFormatTags[] = {
41
31
    { PIX_FMT_YUV420P, MKTAG('I', '4', '2', '0') }, /* Planar formats */
42
32
    { PIX_FMT_YUV420P, MKTAG('I', 'Y', 'U', 'V') },
43
33
    { PIX_FMT_YUV420P, MKTAG('Y', 'V', '1', '2') },
51
41
    { PIX_FMT_YUYV422, MKTAG('Y', 'U', 'Y', '2') }, /* Packed formats */
52
42
    { PIX_FMT_YUYV422, MKTAG('Y', '4', '2', '2') },
53
43
    { PIX_FMT_UYVY422, MKTAG('U', 'Y', 'V', 'Y') },
 
44
    { PIX_FMT_UYVY422, MKTAG('H', 'D', 'Y', 'C') },
54
45
    { PIX_FMT_GRAY8,   MKTAG('G', 'R', 'E', 'Y') },
55
46
    { PIX_FMT_RGB555,  MKTAG('R', 'G', 'B', 15) },
56
47
    { PIX_FMT_BGR555,  MKTAG('B', 'G', 'R', 15) },
59
50
 
60
51
    /* quicktime */
61
52
    { PIX_FMT_UYVY422, MKTAG('2', 'v', 'u', 'y') },
62
 
 
63
 
    { -1, 0 },
64
 
};
65
 
 
66
 
static const PixelFormatTag pixelFormatBpsAVI[] = {
67
 
    { PIX_FMT_PAL8,    8 },
68
 
    { PIX_FMT_RGB555, 15 },
69
 
    { PIX_FMT_RGB555, 16 },
70
 
    { PIX_FMT_BGR24,  24 },
71
 
    { PIX_FMT_RGB32,  32 },
72
 
    { -1, 0 },
73
 
};
74
 
 
75
 
static const PixelFormatTag pixelFormatBpsMOV[] = {
76
 
    /* FIXME fix swscaler to support those */
77
 
    /* http://developer.apple.com/documentation/QuickTime/QTFF/QTFFChap3/chapter_4_section_2.html */
78
 
    { PIX_FMT_PAL8,      8 },
79
 
    { PIX_FMT_BGR555,   16 },
80
 
    { PIX_FMT_RGB24,    24 },
81
 
    { PIX_FMT_BGR32_1,  32 },
82
 
    { -1, 0 },
83
 
};
84
 
 
85
 
static int findPixelFormat(const PixelFormatTag *tags, unsigned int fourcc)
86
 
{
87
 
    while (tags->pix_fmt >= 0) {
88
 
        if (tags->fourcc == fourcc)
89
 
            return tags->pix_fmt;
90
 
        tags++;
91
 
    }
92
 
    return PIX_FMT_YUV420P;
93
 
}
 
53
    { PIX_FMT_UYVY422, MKTAG('A', 'V', 'U', 'I') }, /* FIXME merge both fields */
 
54
 
 
55
    { -1, 0 },
 
56
};
94
57
 
95
58
unsigned int avcodec_pix_fmt_to_codec_tag(enum PixelFormat fmt)
96
59
{
97
 
    const PixelFormatTag * tags = pixelFormatTags;
 
60
    const PixelFormatTag * tags = ff_raw_pixelFormatTags;
98
61
    while (tags->pix_fmt >= 0) {
99
62
        if (tags->pix_fmt == fmt)
100
63
            return tags->fourcc;
102
65
    }
103
66
    return 0;
104
67
}
105
 
 
106
 
/* RAW Decoder Implementation */
107
 
 
108
 
static int raw_init_decoder(AVCodecContext *avctx)
109
 
{
110
 
    RawVideoContext *context = avctx->priv_data;
111
 
 
112
 
    if (avctx->codec_tag == MKTAG('r','a','w',' '))
113
 
        avctx->pix_fmt = findPixelFormat(pixelFormatBpsMOV, avctx->bits_per_sample);
114
 
    else if (avctx->codec_tag)
115
 
        avctx->pix_fmt = findPixelFormat(pixelFormatTags,   avctx->codec_tag);
116
 
    else if (avctx->bits_per_sample)
117
 
        avctx->pix_fmt = findPixelFormat(pixelFormatBpsAVI, avctx->bits_per_sample);
118
 
 
119
 
    context->length = avpicture_get_size(avctx->pix_fmt, avctx->width, avctx->height);
120
 
    context->buffer = av_malloc(context->length);
121
 
    context->pic.pict_type = FF_I_TYPE;
122
 
    context->pic.key_frame = 1;
123
 
 
124
 
    avctx->coded_frame= &context->pic;
125
 
 
126
 
    if (!context->buffer)
127
 
        return -1;
128
 
 
129
 
    return 0;
130
 
}
131
 
 
132
 
static void flip(AVCodecContext *avctx, AVPicture * picture){
133
 
    if(!avctx->codec_tag && avctx->bits_per_sample && picture->linesize[2]==0){
134
 
        picture->data[0] += picture->linesize[0] * (avctx->height-1);
135
 
        picture->linesize[0] *= -1;
136
 
    }
137
 
}
138
 
 
139
 
static int raw_decode(AVCodecContext *avctx,
140
 
                            void *data, int *data_size,
141
 
                            uint8_t *buf, int buf_size)
142
 
{
143
 
    RawVideoContext *context = avctx->priv_data;
144
 
 
145
 
    AVFrame * frame = (AVFrame *) data;
146
 
    AVPicture * picture = (AVPicture *) data;
147
 
 
148
 
    frame->interlaced_frame = avctx->coded_frame->interlaced_frame;
149
 
    frame->top_field_first = avctx->coded_frame->top_field_first;
150
 
 
151
 
    if(buf_size < context->length - (avctx->pix_fmt==PIX_FMT_PAL8 ? 256*4 : 0))
152
 
        return -1;
153
 
 
154
 
    avpicture_fill(picture, buf, avctx->pix_fmt, avctx->width, avctx->height);
155
 
    if(avctx->pix_fmt==PIX_FMT_PAL8 && buf_size < context->length){
156
 
        frame->data[1]= context->buffer;
157
 
    }
158
 
    if (avctx->palctrl && avctx->palctrl->palette_changed) {
159
 
        memcpy(frame->data[1], avctx->palctrl->palette, AVPALETTE_SIZE);
160
 
        avctx->palctrl->palette_changed = 0;
161
 
    }
162
 
 
163
 
    flip(avctx, picture);
164
 
 
165
 
    if (avctx->codec_tag == MKTAG('Y', 'V', '1', '2'))
166
 
    {
167
 
        // swap fields
168
 
        unsigned char *tmp = picture->data[1];
169
 
        picture->data[1] = picture->data[2];
170
 
        picture->data[2] = tmp;
171
 
    }
172
 
 
173
 
    *data_size = sizeof(AVPicture);
174
 
    return buf_size;
175
 
}
176
 
 
177
 
static int raw_close_decoder(AVCodecContext *avctx)
178
 
{
179
 
    RawVideoContext *context = avctx->priv_data;
180
 
 
181
 
    av_freep(&context->buffer);
182
 
    return 0;
183
 
}
184
 
 
185
 
/* RAW Encoder Implementation */
186
 
#ifdef CONFIG_RAWVIDEO_ENCODER
187
 
static int raw_init_encoder(AVCodecContext *avctx)
188
 
{
189
 
    avctx->coded_frame = (AVFrame *)avctx->priv_data;
190
 
    avctx->coded_frame->pict_type = FF_I_TYPE;
191
 
    avctx->coded_frame->key_frame = 1;
192
 
    if(!avctx->codec_tag)
193
 
        avctx->codec_tag = avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
194
 
    return 0;
195
 
}
196
 
 
197
 
static int raw_encode(AVCodecContext *avctx,
198
 
                            unsigned char *frame, int buf_size, void *data)
199
 
{
200
 
    return avpicture_layout((AVPicture *)data, avctx->pix_fmt, avctx->width,
201
 
                                               avctx->height, frame, buf_size);
202
 
}
203
 
 
204
 
AVCodec rawvideo_encoder = {
205
 
    "rawvideo",
206
 
    CODEC_TYPE_VIDEO,
207
 
    CODEC_ID_RAWVIDEO,
208
 
    sizeof(AVFrame),
209
 
    raw_init_encoder,
210
 
    raw_encode,
211
 
};
212
 
#endif // CONFIG_RAWVIDEO_ENCODER
213
 
 
214
 
AVCodec rawvideo_decoder = {
215
 
    "rawvideo",
216
 
    CODEC_TYPE_VIDEO,
217
 
    CODEC_ID_RAWVIDEO,
218
 
    sizeof(RawVideoContext),
219
 
    raw_init_decoder,
220
 
    NULL,
221
 
    raw_close_decoder,
222
 
    raw_decode,
223
 
};