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