← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/libopenjpeg.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2012-01-12 22:23:28 UTC
  • mfrom: (0.4.7 sid)
  • mto: This revision was merged to the branch mainline in revision 76.
  • Revision ID: package-import@ubuntu.com-20120112222328-8jqdyodym3p84ygu
Tags: 2:1.0~rc4.dfsg1+svn34540-1
* New upstream snapshot
* upload to unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/libopenjpeg.c
27
27
#include "libavutil/imgutils.h"
28
28
#include "avcodec.h"
29
29
#include "libavutil/intreadwrite.h"
 
30
#include "thread.h"
30
31
#define  OPJ_STATIC
31
32
#include <openjpeg.h>
32
33
 
57
58
    return 0;
58
59
}
59
60
 
 
61
static av_cold int libopenjpeg_decode_init_thread_copy(AVCodecContext *avctx)
 
62
{
 
63
    LibOpenJPEGContext *ctx = avctx->priv_data;
 
64
 
 
65
    avctx->coded_frame = &ctx->image;
 
66
    return 0;
 
67
}
 
68
 
60
69
static int libopenjpeg_decode_frame(AVCodecContext *avctx,
61
70
                                    void *data, int *data_size,
62
71
                                    AVPacket *avpkt)
63
72
{
64
 
    const uint8_t *buf = avpkt->data;
 
73
    uint8_t *buf = avpkt->data;
65
74
    int buf_size = avpkt->size;
66
75
    LibOpenJPEGContext *ctx = avctx->priv_data;
67
76
    AVFrame *picture = &ctx->image, *output = data;
94
103
    }
95
104
    opj_set_event_mgr((opj_common_ptr)dec, NULL, NULL);
96
105
 
97
 
    ctx->dec_params.cp_reduce = avctx->lowres;
 
106
    ctx->dec_params.cp_limit_decoding = LIMIT_TO_MAIN_HEADER;
98
107
    // Tie decoder with decoding parameters
99
108
    opj_setup_decoder(dec, &ctx->dec_params);
100
109
    stream = opj_cio_open((opj_common_ptr)dec, buf, buf_size);
104
113
        return -1;
105
114
    }
106
115
 
107
 
    // Decode the codestream
 
116
    // Decode the header only
108
117
    image = opj_decode_with_info(dec, stream, NULL);
109
118
    opj_cio_close(stream);
110
119
    if(!image) {
112
121
        opj_destroy_decompress(dec);
113
122
        return -1;
114
123
    }
115
 
    width  = image->comps[0].w << avctx->lowres;
116
 
    height = image->comps[0].h << avctx->lowres;
 
124
    width  = image->x1 - image->x0;
 
125
    height = image->y1 - image->y0;
117
126
    if(av_image_check_size(width, height, 0, avctx) < 0) {
118
127
        av_log(avctx, AV_LOG_ERROR, "%dx%d dimension invalid.\n", width, height);
119
128
        goto done;
139
148
    }
140
149
 
141
150
    if(picture->data[0])
142
 
        avctx->release_buffer(avctx, picture);
143
 
 
144
 
    if(avctx->get_buffer(avctx, picture) < 0) {
145
 
        av_log(avctx, AV_LOG_ERROR, "Couldn't allocate image buffer.\n");
146
 
        return -1;
147
 
    }
 
151
        ff_thread_release_buffer(avctx, picture);
 
152
 
 
153
    if(ff_thread_get_buffer(avctx, picture) < 0){
 
154
        av_log(avctx, AV_LOG_ERROR, "ff_thread_get_buffer() failed\n");
 
155
        return -1;
 
156
    }
 
157
 
 
158
    ff_thread_finish_setup(avctx);
 
159
 
 
160
    ctx->dec_params.cp_limit_decoding = NO_LIMITATION;
 
161
    ctx->dec_params.cp_reduce = avctx->lowres;
 
162
    // Tie decoder with decoding parameters
 
163
    opj_setup_decoder(dec, &ctx->dec_params);
 
164
    stream = opj_cio_open((opj_common_ptr)dec, buf, buf_size);
 
165
    if(!stream) {
 
166
        av_log(avctx, AV_LOG_ERROR, "Codestream could not be opened for reading.\n");
 
167
        opj_destroy_decompress(dec);
 
168
        return -1;
 
169
    }
 
170
 
 
171
    // Decode the codestream
 
172
    image = opj_decode_with_info(dec, stream, NULL);
 
173
    opj_cio_close(stream);
148
174
 
149
175
    for(x = 0; x < image->numcomps; x++) {
150
176
        adjust[x] = FFMAX(image->comps[x].prec - 8, 0);
179
205
    LibOpenJPEGContext *ctx = avctx->priv_data;
180
206
 
181
207
    if(ctx->image.data[0])
182
 
        avctx->release_buffer(avctx, &ctx->image);
 
208
        ff_thread_release_buffer(avctx, &ctx->image);
183
209
    return 0 ;
184
210
}
185
211
 
186
212
 
187
213
AVCodec ff_libopenjpeg_decoder = {
188
 
    "libopenjpeg",
189
 
    AVMEDIA_TYPE_VIDEO,
190
 
    CODEC_ID_JPEG2000,
191
 
    sizeof(LibOpenJPEGContext),
192
 
    libopenjpeg_decode_init,
193
 
    NULL,
194
 
    libopenjpeg_decode_close,
195
 
    libopenjpeg_decode_frame,
196
 
    CODEC_CAP_DR1,
197
 
    .max_lowres = 5,
198
 
    .long_name = NULL_IF_CONFIG_SMALL("OpenJPEG based JPEG 2000 decoder"),
199
 
} ;
 
214
    .name           = "libopenjpeg",
 
215
    .type           = AVMEDIA_TYPE_VIDEO,
 
216
    .id             = CODEC_ID_JPEG2000,
 
217
    .priv_data_size = sizeof(LibOpenJPEGContext),
 
218
    .init           = libopenjpeg_decode_init,
 
219
    .close          = libopenjpeg_decode_close,
 
220
    .decode         = libopenjpeg_decode_frame,
 
221
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
 
222
    .max_lowres     = 5,
 
223
    .long_name      = NULL_IF_CONFIG_SMALL("OpenJPEG based JPEG 2000 decoder"),
 
224
    .init_thread_copy = ONLY_IF_THREADS_ENABLED(libopenjpeg_decode_init_thread_copy)
 
225
};