drm_framework_common.h revision 5c26937264d9748a3db2a554c188e517523aa31a 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef __DRM_FRAMEWORK_COMMON_H__
18#define __DRM_FRAMEWORK_COMMON_H__
19
20#include <utils/Vector.h>
21#include <utils/KeyedVector.h>
22#include <utils/RefBase.h>
23#include <utils/String8.h>
24#include <utils/Errors.h>
25
26#define INVALID_VALUE -1
27
28namespace android {
29
30/**
31 * Error code for DRM Frameowrk
32 */
33enum {
34    // The following constant values should be in sync with
35    // media/stagefright/MediaErrors.h
36    ERROR_BASE = -2000,
37
38    DRM_ERROR_UNKNOWN                       = ERROR_BASE,
39    DRM_ERROR_NO_LICENSE                    = ERROR_BASE - 1,
40    DRM_ERROR_LICENSE_EXPIRED               = ERROR_BASE - 2,
41    DRM_ERROR_SESSION_NOT_OPENED            = ERROR_BASE - 3,
42    DRM_ERROR_DECRYPT_UNIT_NOT_INITIALIZED  = ERROR_BASE - 4,
43    DRM_ERROR_DECRYPT                       = ERROR_BASE - 5,
44    DRM_ERROR_CANNOT_HANDLE                 = ERROR_BASE - 6,
45    DRM_ERROR_TAMPER_DETECTED               = ERROR_BASE - 7,
46
47    DRM_NO_ERROR                            = NO_ERROR
48};
49
50/**
51 * copy control settings used in DecryptHandle::copyControlVector
52 */
53enum DrmCopyControl {
54    DRM_COPY_CONTROL_BASE = 1000,
55    // the key used to set the value for HDCP
56    // if the associated value is 1, then HDCP is required
57    // otherwise, HDCP is not required
58    DRM_COPY_CONTROL_HDCP = DRM_COPY_CONTROL_BASE
59};
60
61/**
62 * Defines DRM Buffer
63 */
64class DrmBuffer {
65public:
66    char* data;
67    int length;
68
69    DrmBuffer() :
70        data(NULL),
71        length(0) {
72    }
73
74    DrmBuffer(char* dataBytes, int dataLength) :
75        data(dataBytes),
76        length(dataLength) {
77    }
78
79};
80
81/**
82 * Defines detailed description of the action
83 */
84class ActionDescription {
85public:
86    ActionDescription(int _outputType, int _configuration) :
87        outputType(_outputType),
88        configuration(_configuration) {
89    }
90
91public:
92    int outputType;   /* BLUETOOTH , HDMI*/
93    int configuration; /* RESOLUTION_720_480 , RECORDABLE etc.*/
94};
95
96/**
97 * Defines constants related to DRM types
98 */
99class DrmObjectType {
100private:
101    DrmObjectType();
102
103public:
104    /**
105     * Field specifies the unknown type
106     */
107    static const int UNKNOWN = 0x00;
108    /**
109     * Field specifies the protected content type
110     */
111    static const int CONTENT = 0x01;
112    /**
113     * Field specifies the rights information
114     */
115    static const int RIGHTS_OBJECT = 0x02;
116    /**
117     * Field specifies the trigger information
118     */
119    static const int TRIGGER_OBJECT = 0x03;
120};
121
122/**
123 * Defines constants related to play back
124 */
125class Playback {
126private:
127    Playback();
128
129public:
130    /**
131     * Constant field signifies playback start
132     */
133    static const int START = 0x00;
134    /**
135     * Constant field signifies playback stop
136     */
137    static const int STOP = 0x01;
138    /**
139     * Constant field signifies playback paused
140     */
141    static const int PAUSE = 0x02;
142    /**
143     * Constant field signifies playback resumed
144     */
145    static const int RESUME = 0x03;
146};
147
148/**
149 * Defines actions that can be performed on protected content
150 */
151class Action {
152private:
153    Action();
154
155public:
156    /**
157     * Constant field signifies that the default action
158     */
159    static const int DEFAULT = 0x00;
160    /**
161     * Constant field signifies that the content can be played
162     */
163    static const int PLAY = 0x01;
164    /**
165     * Constant field signifies that the content can be set as ring tone
166     */
167    static const int RINGTONE = 0x02;
168    /**
169     * Constant field signifies that the content can be transfered
170     */
171    static const int TRANSFER = 0x03;
172    /**
173     * Constant field signifies that the content can be set as output
174     */
175    static const int OUTPUT = 0x04;
176    /**
177     * Constant field signifies that preview is allowed
178     */
179    static const int PREVIEW = 0x05;
180    /**
181     * Constant field signifies that the content can be executed
182     */
183    static const int EXECUTE = 0x06;
184    /**
185     * Constant field signifies that the content can displayed
186     */
187    static const int DISPLAY = 0x07;
188};
189
190/**
191 * Defines constants related to status of the rights
192 */
193class RightsStatus {
194private:
195    RightsStatus();
196
197public:
198    /**
199     * Constant field signifies that the rights are valid
200     */
201    static const int RIGHTS_VALID = 0x00;
202    /**
203     * Constant field signifies that the rights are invalid
204     */
205    static const int RIGHTS_INVALID = 0x01;
206    /**
207     * Constant field signifies that the rights are expired for the content
208     */
209    static const int RIGHTS_EXPIRED = 0x02;
210    /**
211     * Constant field signifies that the rights are not acquired for the content
212     */
213    static const int RIGHTS_NOT_ACQUIRED = 0x03;
214};
215
216/**
217 * Defines API set for decryption
218 */
219class DecryptApiType {
220private:
221    DecryptApiType();
222
223public:
224    /**
225     * Decrypt API set for non encrypted content
226     */
227    static const int NON_ENCRYPTED = 0x00;
228    /**
229     * Decrypt API set for ES based DRM
230     */
231    static const int ELEMENTARY_STREAM_BASED = 0x01;
232    /**
233     * POSIX based Decrypt API set for container based DRM
234     */
235    static const int CONTAINER_BASED = 0x02;
236    /**
237     * Decrypt API for Widevine streams
238     */
239    static const int WV_BASED = 0x3;
240};
241
242/**
243 * Defines decryption information
244 */
245class DecryptInfo {
246public:
247    /**
248     * size of memory to be allocated to get the decrypted content.
249     */
250    int decryptBufferLength;
251    /**
252     * reserved for future purpose
253     */
254};
255
256/**
257 * Defines decryption handle
258 */
259class DecryptHandle : public RefBase {
260public:
261    /**
262     * Decryption session Handle
263     */
264    int decryptId;
265    /**
266     * Mimetype of the content to be used to select the media extractor
267     * For e.g., "video/mpeg" or "audio/mp3"
268     */
269    String8 mimeType;
270    /**
271     * Defines which decryption pattern should be used to decrypt the given content
272     * DrmFramework provides two different set of decryption APIs.
273     *   1. Decrypt APIs for elementary stream based DRM
274     *      (file format is not encrypted but ES is encrypted)
275     *         e.g., Marlin DRM (MP4 file format), WM-DRM (asf file format)
276     *
277     *         DecryptApiType::ELEMENTARY_STREAM_BASED
278     *             Decryption API set for ES based DRM
279     *                 initializeDecryptUnit(), decrypt(), and finalizeDecryptUnit()
280     *   2. Decrypt APIs for container based DRM (file format itself is encrypted)
281     *         e.g., OMA DRM (dcf file format)
282     *
283     *         DecryptApiType::CONTAINER_BASED
284     *             POSIX based Decryption API set for container based DRM
285     *                 pread()
286     */
287    int decryptApiType;
288    /**
289     * Defines the status of the rights like
290     *     RIGHTS_VALID, RIGHTS_INVALID, RIGHTS_EXPIRED or RIGHTS_NOT_ACQUIRED
291     */
292    int status;
293    /**
294     * Information required to decrypt content
295     * e.g. size of memory to be allocated to get the decrypted content.
296     */
297    DecryptInfo* decryptInfo;
298    /**
299     * Defines a vector for the copy control settings sent from the DRM plugin
300     * to the player
301     */
302    KeyedVector<DrmCopyControl, int> copyControlVector;
303
304    /**
305     * Defines a vector for any extra data the DRM plugin wants to send
306     * to the native code
307     */
308    KeyedVector<String8, String8> extendedData;
309
310public:
311    DecryptHandle():
312            decryptId(INVALID_VALUE),
313            mimeType(""),
314            decryptApiType(INVALID_VALUE),
315            status(INVALID_VALUE),
316            decryptInfo(NULL) {
317
318    }
319
320    ~DecryptHandle() {
321        delete decryptInfo; decryptInfo = NULL;
322    }
323
324    bool operator<(const DecryptHandle& handle) const {
325        return (decryptId < handle.decryptId);
326    }
327
328    bool operator==(const DecryptHandle& handle) const {
329        return (decryptId == handle.decryptId);
330    }
331};
332
333};
334
335#endif /* __DRM_FRAMEWORK_COMMON_H__ */
336
337