code.vuplus.com Git - vuplus_xbmc/blob - xbmc/cores/dvdplayer/DVDCodecs/Video/DVDVideoCodec.h

   1 #pragma once
   2
   3 /*
   4  *      Copyright (C) 2005-2013 Team XBMC
   5  *      http://xbmc.org
   6  *
   7  *  This Program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2, or (at your option)
  10  *  any later version.
  11  *
  12  *  This Program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with XBMC; see the file COPYING.  If not, see
  19  *  <http://www.gnu.org/licenses/>.
  20  *
  21  */
  22
  23 #include "system.h"
  24
  25 #include <vector>
  26 #include "cores/VideoRenderers/RenderFormats.h"
  27
  28 // when modifying these structures, make sure you update all codecs accordingly
  29 #define FRAME_TYPE_UNDEF 0
  30 #define FRAME_TYPE_I 1
  31 #define FRAME_TYPE_P 2
  32 #define FRAME_TYPE_B 3
  33 #define FRAME_TYPE_D 4
  34
  35 namespace DXVA { class CSurfaceContext; }
  36 namespace VAAPI { struct CHolder; }
  37 namespace VDPAU { class CVdpauRenderPicture; }
  38 class COpenMax;
  39 class COpenMaxVideo;
  40 struct OpenMaxVideoBuffer;
  41 class CStageFrightVideo;
  42 class CDVDMediaCodecInfo;
  43 typedef void* EGLImageKHR;
  44
  45
  46 // should be entirely filled by all codecs
  47 struct DVDVideoPicture
  48 {
  49   double pts; // timestamp in seconds, used in the CDVDPlayer class to keep track of pts
  50   double dts;
  51
  52   union
  53   {
  54     struct {
  55       uint8_t* data[4];      // [4] = alpha channel, currently not used
  56       int iLineSize[4];   // [4] = alpha channel, currently not used
  57     };
  58     struct {
  59       DXVA::CSurfaceContext* context;
  60     };
  61     struct {
  62       VDPAU::CVdpauRenderPicture* vdpau;
  63     };
  64     struct {
  65       VAAPI::CHolder* vaapi;
  66     };
  67
  68     struct {
  69       COpenMax *openMax;
  70       OpenMaxVideoBuffer *openMaxBuffer;
  71     };
  72
  73     struct {
  74       struct __CVBuffer *cvBufferRef;
  75     };
  76
  77     struct {
  78       CStageFrightVideo* stf;
  79       EGLImageKHR eglimg;
  80     };
  81
  82     struct {
  83       CDVDMediaCodecInfo *mediacodec;
  84     };
  85   };
  86
  87   unsigned int iFlags;
  88
  89   double       iRepeatPicture;
  90   double       iDuration;
  91   unsigned int iFrameType         : 4; // see defines above // 1->I, 2->P, 3->B, 0->Undef
  92   unsigned int color_matrix       : 4;
  93   unsigned int color_range        : 1; // 1 indicate if we have a full range of color
  94   unsigned int chroma_position;
  95   unsigned int color_primaries;
  96   unsigned int color_transfer;
  97   unsigned int extended_format;
  98   char         stereo_mode[32];
  99
 100   int8_t* qscale_table; // Quantization parameters, primarily used by filters
 101   int qscale_stride;
 102   int qscale_type;
 103
 104   unsigned int iWidth;
 105   unsigned int iHeight;
 106   unsigned int iDisplayWidth;  // width of the picture without black bars
 107   unsigned int iDisplayHeight; // height of the picture without black bars
 108
 109   ERenderFormat format;
 110 };
 111
 112 struct DVDVideoUserData
 113 {
 114   uint8_t* data;
 115   int size;
 116 };
 117
 118 #define DVP_FLAG_TOP_FIELD_FIRST    0x00000001
 119 #define DVP_FLAG_REPEAT_TOP_FIELD   0x00000002 //Set to indicate that the top field should be repeated
 120 #define DVP_FLAG_ALLOCATED          0x00000004 //Set to indicate that this has allocated data
 121 #define DVP_FLAG_INTERLACED         0x00000008 //Set to indicate that this frame is interlaced
 122
 123 #define DVP_FLAG_NOSKIP             0x00000010 // indicate this picture should never be dropped
 124 #define DVP_FLAG_DROPPED            0x00000020 // indicate that this picture has been dropped in decoder stage, will have no data
 125
 126 // DVP_FLAG 0x00000100 - 0x00000f00 is in use by libmpeg2!
 127
 128 #define DVP_QSCALE_UNKNOWN          0
 129 #define DVP_QSCALE_MPEG1            1
 130 #define DVP_QSCALE_MPEG2            2
 131 #define DVP_QSCALE_H264             3
 132
 133 class CDVDStreamInfo;
 134 class CDVDCodecOption;
 135 class CDVDCodecOptions;
 136
 137 // VC_ messages, messages can be combined
 138 #define VC_ERROR    0x00000001  // an error occured, no other messages will be returned
 139 #define VC_BUFFER   0x00000002  // the decoder needs more data
 140 #define VC_PICTURE  0x00000004  // the decoder got a picture, call Decode(NULL, 0) again to parse the rest of the data
 141 #define VC_USERDATA 0x00000008  // the decoder found some userdata,  call Decode(NULL, 0) again to parse the rest of the data
 142 #define VC_FLUSHED  0x00000010  // the decoder lost it's state, we need to restart decoding again
 143 class CDVDVideoCodec
 144 {
 145 public:
 146
 147   CDVDVideoCodec() {}
 148   virtual ~CDVDVideoCodec() {}
 149
 150   /*
 151    * Open the decoder, returns true on success
 152    */
 153   virtual bool Open(CDVDStreamInfo &hints, CDVDCodecOptions &options) = 0;
 154
 155   /*
 156    * Dispose, Free all resources
 157    */
 158   virtual void Dispose() = 0;
 159
 160   /*
 161    * returns one or a combination of VC_ messages
 162    * pData and iSize can be NULL, this means we should flush the rest of the data.
 163    */
 164   virtual int Decode(uint8_t* pData, int iSize, double dts, double pts) = 0;
 165
 166  /*
 167    * Reset the decoder.
 168    * Should be the same as calling Dispose and Open after each other
 169    */
 170   virtual void Reset() = 0;
 171
 172   /*
 173    * returns true if successfull
 174    * the data is valid until the next Decode call
 175    */
 176   virtual bool GetPicture(DVDVideoPicture* pDvdVideoPicture) = 0;
 177
 178
 179   /*
 180    * returns true if successfull
 181    * the data is cleared to zero
 182    */
 183   virtual bool ClearPicture(DVDVideoPicture* pDvdVideoPicture)
 184   {
 185     memset(pDvdVideoPicture, 0, sizeof(DVDVideoPicture));
 186     return true;
 187   }
 188
 189   /*
 190    * returns true if successfull
 191    * the data is valid until the next Decode call
 192    * userdata can be anything, for now we use it for closed captioning
 193    */
 194   virtual bool GetUserData(DVDVideoUserData* pDvdVideoUserData)
 195   {
 196     pDvdVideoUserData->data = NULL;
 197     pDvdVideoUserData->size = 0;
 198     return false;
 199   }
 200
 201   /*
 202    * will be called by video player indicating if a frame will eventually be dropped
 203    * codec can then skip actually decoding the data, just consume the data set picture headers
 204    */
 205   virtual void SetDropState(bool bDrop) = 0;
 206
 207   /*
 208    * will be called by video player indicating the playback speed. see DVD_PLAYSPEED_NORMAL,
 209    * DVD_PLAYSPEED_PAUSE and friends.
 210    */
 211   virtual void SetSpeed(int iSpeed) {};
 212
 213   /*
 214    * returns the number of demuxer bytes in any internal buffers
 215    */
 216   virtual int GetDataSize(void)
 217   {
 218     return 0;
 219   }
 220
 221   /*
 222    * returns the time in seconds for demuxer bytes in any internal buffers
 223    */
 224   virtual double GetTimeSize(void)
 225   {
 226     return 0;
 227   }
 228
 229   enum EFilterFlags {
 230     FILTER_NONE                =  0x0,
 231     FILTER_DEINTERLACE_YADIF   =  0x1,  /* use first deinterlace mode */
 232     FILTER_DEINTERLACE_ANY     =  0xf,  /* use any deinterlace mode */
 233     FILTER_DEINTERLACE_FLAGGED = 0x10,  /* only deinterlace flagged frames */
 234     FILTER_DEINTERLACE_HALFED  = 0x20,  /* do half rate deinterlacing */
 235     FILTER_ROTATE              = 0x40,  /* rotate image according to the codec hints */
 236   };
 237
 238   /*
 239    * set the type of filters that should be applied at decoding stage if possible
 240    */
 241   virtual unsigned int SetFilters(unsigned int filters) { return 0u; }
 242
 243   /*
 244    *
 245    * should return codecs name
 246    */
 247   virtual const char* GetName() = 0;
 248
 249   /*
 250    *
 251    * How many packets should player remember, so codec
 252    * can recover should something cause it to flush
 253    * outside of players control
 254    */
 255   virtual unsigned GetConvergeCount()
 256   {
 257     return 0;
 258   }
 259
 260
 261   /**
 262    * Number of references to old pictures that are allowed to
 263    * be retained when calling decode on the next demux packet
 264    */
 265   virtual unsigned GetAllowedReferences() { return 0; }
 266 };