← Back to branch summary

~ubuntu-branches/ubuntu/maverick/blender/maverick

« back to all changes in this revision

Viewing changes to extern/libredcode/codec.c

  • Committer: Bazaar Package Importer
  • Author(s): Khashayar Naderehvandi, Khashayar Naderehvandi, Alessio Treglia
  • Date: 2009-01-22 16:53:59 UTC
  • mfrom: (14.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20090122165359-v0996tn7fbit64ni
Tags: 2.48a+dfsg-1ubuntu1
https://launchpad.net/bugs/320045
[ Khashayar Naderehvandi ]
* Merge from debian experimental (LP: #320045), Ubuntu remaining changes:
  - Add patch correcting header file locations.
  - Add libvorbis-dev and libgsm1-dev to Build-Depends.
  - Use avcodec_decode_audio2() in source/blender/src/hddaudio.c

[ Alessio Treglia ]
* Add missing previous changelog entries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
extern/libredcode/codec.c
 
1
#include "codec.h"
 
2
#include "format.h"
 
3
#include "debayer.h"
 
4
 
 
5
#include <openjpeg.h>
 
6
#include <stdlib.h>
 
7
#include <stdio.h>
 
8
#include <string.h>
 
9
 
 
10
static void error_callback(const char *msg, void *client_data) {
 
11
        FILE *stream = (FILE*)client_data;
 
12
        fprintf(stream, "[R3D ERR] %s", msg);
 
13
}
 
14
 
 
15
static void warning_callback(const char *msg, void *client_data) {
 
16
        FILE *stream = (FILE*)client_data;
 
17
        fprintf(stream, "[R3D WARN] %s", msg);
 
18
}
 
19
 
 
20
static void info_callback(const char *msg, void *client_data) {
 
21
        (void)client_data;
 
22
        fprintf(stdout, "[R3D INFO] %s", msg);
 
23
}
 
24
 
 
25
#define J2K_CFMT 0
 
26
#define JP2_CFMT 1
 
27
#define JPT_CFMT 2
 
28
 
 
29
struct redcode_frame_raw * redcode_decode_video_raw(
 
30
        struct redcode_frame * frame, int scale)
 
31
{
 
32
        struct redcode_frame_raw * rv = NULL;
 
33
        opj_dparameters_t parameters;   /* decompression parameters */
 
34
        opj_event_mgr_t event_mgr;              /* event manager */
 
35
        opj_image_t *image = NULL;
 
36
        opj_dinfo_t* dinfo = NULL;      /* handle to a decompressor */
 
37
        opj_cio_t *cio = NULL;
 
38
 
 
39
        memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
 
40
        event_mgr.error_handler = error_callback;
 
41
        event_mgr.warning_handler = warning_callback;
 
42
        event_mgr.info_handler = info_callback;
 
43
 
 
44
        opj_set_default_decoder_parameters(&parameters);
 
45
 
 
46
        parameters.decod_format = JP2_CFMT;
 
47
 
 
48
        if (scale == 2) {
 
49
                parameters.cp_reduce = 1;
 
50
        } else if (scale == 4) {
 
51
                parameters.cp_reduce = 2;
 
52
        } else if (scale == 8) {
 
53
                parameters.cp_reduce = 3;
 
54
        }
 
55
 
 
56
        /* JPEG 2000 compressed image data */
 
57
        
 
58
        /* get a decoder handle */
 
59
        dinfo = opj_create_decompress(CODEC_JP2);
 
60
 
 
61
        /* catch events using our callbacks and give a local context */
 
62
        opj_set_event_mgr((opj_common_ptr)dinfo, &event_mgr, stderr);
 
63
        
 
64
        /* setup the decoder decoding parameters using the current image 
 
65
           and user parameters */
 
66
        opj_setup_decoder(dinfo, &parameters);
 
67
                        
 
68
        /* open a byte stream */
 
69
        cio = opj_cio_open((opj_common_ptr)dinfo, 
 
70
                           frame->data + frame->offset, frame->length);
 
71
 
 
72
        image = opj_decode(dinfo, cio);                 
 
73
 
 
74
        if(!image) {
 
75
                fprintf(stderr, 
 
76
                        "ERROR -> j2k_to_image: failed to decode image!\n");
 
77
                opj_destroy_decompress(dinfo);
 
78
                opj_cio_close(cio);
 
79
                return 0;
 
80
        }
 
81
 
 
82
        /* close the byte stream */
 
83
        opj_cio_close(cio);
 
84
 
 
85
        /* free remaining structures */
 
86
        if(dinfo) {
 
87
                opj_destroy_decompress(dinfo);
 
88
        }
 
89
 
 
90
        if((image->numcomps * image->x1 * image->y1) == 0) {
 
91
                opj_image_destroy(image);
 
92
                return 0;
 
93
        }
 
94
                
 
95
        rv = (struct redcode_frame_raw *) calloc(
 
96
                1, sizeof(struct redcode_frame_raw));
 
97
 
 
98
        rv->data = image;
 
99
        rv->width = image->comps[0].w;
 
100
        rv->height = image->comps[0].h;
 
101
 
 
102
        return rv;
 
103
}
 
104
 
 
105
int redcode_decode_video_float(struct redcode_frame_raw * frame, 
 
106
                               float * out, int scale)
 
107
{
 
108
        int* planes[4];
 
109
        int i;
 
110
        opj_image_t *image = (opj_image_t*) frame->data;
 
111
 
 
112
        if (image->numcomps != 4) {
 
113
                fprintf(stderr, "R3D: need 4 planes, but got: %d\n",
 
114
                        image->numcomps);
 
115
                return 0;
 
116
        }
 
117
 
 
118
        for (i = 0; i < 4; i++) {
 
119
                planes[i] = image->comps[i].data;
 
120
        }
 
121
 
 
122
        if (scale == 1) {
 
123
                redcode_ycbcr2rgb_fullscale(
 
124
                        planes, frame->width, frame->height, out);
 
125
        } else if (scale == 2) {
 
126
                redcode_ycbcr2rgb_halfscale(
 
127
                        planes, frame->width, frame->height, out);
 
128
        } else if (scale == 4) {
 
129
                redcode_ycbcr2rgb_quarterscale(
 
130
                        planes, frame->width, frame->height, out);
 
131
        }
 
132
 
 
133
        opj_image_destroy(image);
 
134
 
 
135
        free(frame);
 
136
 
 
137
        return 1;
 
138
}
 
139
 
 
140
 
 
141