rawIOpgm.cpp

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  *
   3  * $Id$
   4  *
   5  * The MIT License
   6  *
   7  * Copyright (c) 2008 BBC Research
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a copy
  10  * of this software and associated documentation files (the "Software"), to deal
  11  * in the Software without restriction, including without limitation the rights
  12  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  13  * copies of the Software, and to permit persons to whom the Software is
  14  * furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in
  17  * all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  22  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  25  * THE SOFTWARE.
  26  *
  27  * ***** END LICENSE BLOCK ***** */
  28
  29 #include <assert.h>
  30 #include <math.h>
  31
  32 #include "rawIOpgm.h"
  33
  34 void RawWriterpgm::writeCr42x(const RawFrame& f) const
  35 {
  36         /* YYYY (Planar)
  37          * CbCr
  38          */
  39         fprintf(outfile, "P5 %d %d %d\n", f.luma.width(), f.luma.height()
  40             + f.cr.height(), (1 << depth) - 1);
  41
  42         if (depth > 8) {
  43                 int mask = (1 << (depth - 8)) - 1;
  44                 int zero_shift = 0;
  45                 /* luma first */
  46                 for (int y = 0; y < f.luma.height(); y++)
  47                         for (int x = 0; x < f.luma.width(); x++) {
  48                                 fputc((f.luma[y][x] >> 8) & mask, outfile);
  49                                 fputc((f.luma[y][x] & 0xff), outfile);
  50                         }
  51
  52                 /* chroma second (side by side) */
  53                 for (int y = 0; y < f.cb.height(); y++) {
  54                         for (int x = 0; x < f.cb.width(); x++) {
  55                                 int val = zero_shift + f.cb[y][x];
  56                                 fputc((val >> 8) & mask, outfile);
  57                                 fputc(val & 0xff, outfile);
  58                         }
  59
  60                         for (int x = 0; x < f.cr.width(); x++) {
  61                                 int val = zero_shift + f.cr[y][x];
  62                                 fputc((val >> 8) & mask, outfile);
  63                                 fputc(val & 0xff, outfile);
  64                         }
  65                 }
  66         }
  67         else {
  68                 int zero_shift = 0;
  69                 /* luma first */
  70                 for (int y = 0; y < f.luma.height(); y++)
  71                         for (int x = 0; x < f.luma.width(); x++) {
  72                                 fputc((f.luma[y][x] & 0xff), outfile);
  73                         }
  74
  75                 /* chroma second (side by side) */
  76                 for (int y = 0; y < f.cb.height(); y++) {
  77                         for (int x = 0; x < f.cb.width(); x++) {
  78                                 fputc((zero_shift + f.cb[y][x]) & 0xff, outfile);
  79                         }
  80
  81                         for (int x = 0; x < f.cr.width(); x++) {
  82                                 fputc((zero_shift + f.cr[y][x]) & 0xff, outfile);
  83                         }
  84                 }
  85
  86         }
  87 }
  88
  89 void RawWriterpgm::writeYOnly(const RawFrame& f) const
  90 {
  91         /* YYYY (Planar)
  92          * CbCr
  93          */
  94         assert(f.chroma == RawFrame::YOnly);
  95
  96         fprintf(outfile, "P5 %d %d %d\n", f.luma.width(), f.luma.height(), (1
  97             << depth) - 1);
  98
  99         if (depth > 8) {
 100                 int mask = (1 << (depth - 8)) - 1;
 101                 for (int y = 0; y < f.luma.height(); y++)
 102                         for (int x = 0; x < f.luma.width(); x++) {
 103                                 fputc((f.luma[y][x] >> 8) & mask, outfile);
 104                                 fputc((f.luma[y][x] & 0xff), outfile);
 105                         }
 106         }
 107         else {
 108                 for (int y = 0; y < f.luma.height(); y++)
 109                         for (int x = 0; x < f.luma.width(); x++) {
 110                                 fputc((f.luma[y][x] & 0xff), outfile);
 111                         }
 112         }
 113 }
 114
 115 void RawReaderpgm::readHeader()
 116 {
 117         // This works for our files, but is not generalised:
 118         fscanf(infile, "P5 %d %d %d\n", &_width, &_height, &_maxval);
 119
 120         _depth = (int)ceil(log((double)_maxval) / log(2.0));
 121 }
 122
 123 RawFrame& RawReaderpgm::read(RawFrame &f)
 124 {
 125         //luminance data only
 126         assert(f.chroma == RawFrame::YOnly);
 127
 128         size_t linesRead;
 129         size_t lineLen;
 130
 131         if (_maxval > 255) {
 132                 lineLen = f.luma.width() * 2;
 133                 unsigned char *inLine = new unsigned char[lineLen];
 134
 135                 for (int y = 0; y < _height; y++) {
 136
 137                         linesRead = fread(inLine, lineLen, 1, infile);
 138
 139                         for (int in=0, x=0; x < _width; x++, in+=2)
 140                                 f.luma[y][x]=inLine[in]*256 + inLine[in+1];
 141
 142                         if (linesRead < 1)
 143                                 goto exit1;
 144                 }
 145                 exit1: free(inLine);
 146         }
 147         else {
 148                 lineLen = f.luma.width();
 149                 unsigned char *inLine = new unsigned char[lineLen];
 150
 151                 for (int y = 0; y < _height; y++) {
 152
 153                         linesRead = fread(inLine, lineLen, 1, infile);
 154
 155                         for (int x = 0; x < _width; x++)
 156                                 f.luma[y][x]=inLine[x];
 157
 158                         if (linesRead < 1)
 159                                 goto exit2;
 160                 }
 161                 exit2: free(inLine);
 162         }
 163
 164         //if (feof(infile))
 165         //    throw;
 166         return f;
 167 }
 168
 169 RawFrame& RawReaderpgm::read()
 170 {
 171         throw;
 172 }
 173