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