yuvReaderMmap.cpp

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  *
   3  * The MIT License
   4  *
   5  * Copyright (c) 2008 BBC Research
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23  * THE SOFTWARE.
  24  *
  25  * ***** END LICENSE BLOCK ***** */
  26
  27 #include <QtGui>
  28
  29 #include <stdio.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <fcntl.h>
  33 #include <sstream>
  34
  35 #ifdef Q_OS_UNIX
  36 #include <unistd.h>
  37 #include <sys/mman.h>
  38 #endif
  39
  40 #ifdef Q_OS_MAC
  41 #define lseek64 lseek
  42 #define off64_t off_t
  43 #define mmap64 mmap
  44 #endif
  45
  46 #include "yuvReaderMmap.h"
  47 #include "stats.h"
  48
  49 #define DEBUG 0
  50
  51 YUVReaderMmap::YUVReaderMmap(FrameQueue& frameQ) :
  52         ReaderInterface(frameQ)
  53 {
  54         randomAccess = true;
  55 }
  56
  57 void YUVReaderMmap::setForceFileType(bool f)
  58 {
  59         forceFileType = f;
  60 }
  61
  62 void YUVReaderMmap::setFileType(const QString &t)
  63 {
  64         fileType = t;
  65 }
  66
  67 void YUVReaderMmap::setVideoWidth(int w)
  68 {
  69         videoWidth = w;
  70 }
  71
  72 void YUVReaderMmap::setVideoHeight(int h)
  73 {
  74         videoHeight = h;
  75 }
  76
  77 void YUVReaderMmap::setFileName(const QString &fn)
  78 {
  79         fileName = fn;
  80         QFileInfo info(fileName);
  81
  82         if (DEBUG)
  83                 printf("Opening file %s\n", fileName.toLatin1().data());
  84         fd = open(fileName.toLatin1().data(), O_RDONLY);
  85
  86         if (fd < 0 && DEBUG == 1) {
  87                 printf("[%s]\n", fileName.toLatin1().data());
  88                 perror("OPEN");
  89         }
  90
  91         base_ptr = (char *)mmap64(0, info.size(), PROT_READ, MAP_PRIVATE, fd, 0);
  92
  93         QString type = forceFileType ? fileType.toLower() : info.suffix().toLower();
  94         printf("Playing file with type %s\n", type.toLatin1().data());
  95
  96         firstFrameNum = 0;
  97
  98         if (type == "16p0") {
  99                 videoFormat = VideoData::V16P0;
 100                 lastFrameNum = info.size() / ((videoWidth * videoHeight * 3 * 2) / 2);
 101                 lastFrameNum--;
 102         }
 103
 104         if (type == "16p2") {
 105                 videoFormat = VideoData::V16P2;
 106                 lastFrameNum = info.size() / (videoWidth * videoHeight * 2 * 2);
 107                 lastFrameNum--;
 108         }
 109
 110         if (type == "16p4") {
 111                 videoFormat = VideoData::V16P4;
 112                 lastFrameNum = info.size() / (videoWidth * videoHeight * 3 * 2);
 113                 lastFrameNum--;
 114         }
 115
 116         if (type == "420p") {
 117                 videoFormat = VideoData::V8P0;
 118                 lastFrameNum = info.size() / ((videoWidth * videoHeight * 3) / 2);
 119                 lastFrameNum--;
 120         }
 121
 122         if (type == "422p") {
 123                 videoFormat = VideoData::V8P2;
 124                 lastFrameNum = info.size() / (videoWidth * videoHeight * 2);
 125                 lastFrameNum--;
 126         }
 127
 128         if (type == "444p") {
 129                 videoFormat = VideoData::V8P4;
 130                 lastFrameNum = info.size() / (videoWidth * videoHeight * 3);
 131                 lastFrameNum--;
 132         }
 133
 134         if (type == "i420") {
 135                 videoFormat = VideoData::V8P0;
 136                 lastFrameNum = info.size() / ((videoWidth * videoHeight * 3) / 2);
 137                  lastFrameNum--;
 138         }
 139
 140         if (type == "yv12") {
 141                 videoFormat = VideoData::YV12;
 142                 lastFrameNum = info.size() / ((videoWidth * videoHeight * 3) / 2);
 143                 lastFrameNum--;
 144         }
 145
 146         if (type == "uyvy") {
 147                 videoFormat = VideoData::UYVY;
 148                 lastFrameNum = info.size() / (videoWidth * videoHeight * 2);
 149                 lastFrameNum--;
 150         }
 151
 152         if (type == "v216") {
 153                 videoFormat = VideoData::V216;
 154                 lastFrameNum = info.size() / (videoWidth * videoHeight * 4);
 155                 lastFrameNum--;
 156         }
 157
 158         if (type == "v210") {
 159                 videoFormat = VideoData::V210;
 160                 lastFrameNum = info.size() / ((videoWidth * videoHeight * 2 * 4) / 3);
 161                 lastFrameNum--;
 162         }
 163
 164         {
 165                 Stats &stat = Stats::getInstance();
 166                 std::stringstream ss;
 167
 168                 ss.str("");
 169                 ss << videoWidth;
 170                 stat.addStat("YUVReader (mmap)", "VideoWidth", ss.str());
 171
 172                 ss.str("");
 173                 ss << videoHeight;
 174                 stat.addStat("YUVReader (mmap)", "VideoHeight", ss.str());
 175
 176                 ss.str("");
 177                 ss << firstFrameNum;
 178                 stat.addStat("YUVReader (mmap)", "FirstFrame", ss.str());
 179
 180                 ss.str("");
 181                 ss << lastFrameNum;
 182                 stat.addStat("YUVReader (mmap)", "LastFrame", ss.str());
 183
 184                 stat.addStat("YUVReader (mmap)", "VideoFormat", type.toLatin1().data());
 185         }
 186 }
 187
 188 //called from the frame queue controller to get frame data for display
 189 void YUVReaderMmap::pullFrame(int frameNumber, VideoData*& dst)
 190 {
 191         VideoData* frame = frameQueue.allocateFrame();
 192         frame->resize(videoWidth, videoHeight, videoFormat);
 193
 194         if (DEBUG)
 195                 printf("Getting frame number %d\n", frameNumber);
 196
 197         //deal with frame number wrapping
 198         if (frameNumber < 0) {
 199                 frameNumber *= -1;
 200                 frameNumber %= (lastFrameNum + 1);
 201                 frameNumber = lastFrameNum - frameNumber;
 202         }
 203
 204         if (frameNumber > lastFrameNum)
 205                 frameNumber %= (lastFrameNum + 1);
 206
 207         //set frame number and first/last flags
 208         frame->frameNum = frameNumber;
 209         frame->isFirstFrame = (frameNumber == firstFrameNum);
 210         frame->isLastFrame = (frameNumber == lastFrameNum);
 211         dst = frame;
 212
 213         //calculate offset
 214         off64_t offset = (off_t)dst->dataSize * (off_t)frameNumber; //seek to the wanted frame
 215
 216         //read
 217         int idletime = timer.restart();
 218
 219         memcpy(dst->data, base_ptr + offset, dst->dataSize);
 220
 221         int readtime = timer.restart();
 222
 223         {
 224                 Stats &stat = Stats::getInstance();
 225                 std::stringstream ss;
 226
 227                 ss.str("");
 228                 ss << readtime << "ms";
 229                 stat.addStat("YUVReader (mmap)", "Read", ss.str());
 230
 231                 ss.str("");
 232                 int rate = (dst->dataSize) / (readtime * 1024);
 233                 ss << rate << " MB/s";
 234                 stat.addStat("YUVReader (mmap)", "Peak Rate", ss.str());
 235
 236                 ss.str("");
 237                 int avgrate = (dst->dataSize) / ((readtime + idletime) * 1024);
 238                 ss << avgrate << "MB/s";
 239                 stat.addStat("YUVReader (mmap)", "Avg Rate", ss.str());
 240         }
 241 }