1/*
2 * Copyright (C) 2011 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
18package android.filterfw.core;
19
20import android.filterfw.core.Frame;
21import android.filterfw.core.FrameFormat;
22import android.filterfw.core.FrameManager;
23import android.filterfw.core.NativeBuffer;
24import android.filterfw.format.ObjectFormat;
25import android.graphics.Bitmap;
26
27import java.lang.reflect.Constructor;
28import java.nio.ByteBuffer;
29
30/**
31 * @hide
32 */
33public class SimpleFrame extends Frame {
34
35    private Object mObject;
36
37    SimpleFrame(FrameFormat format, FrameManager frameManager) {
38        super(format, frameManager);
39        initWithFormat(format);
40        setReusable(false);
41    }
42
43    static SimpleFrame wrapObject(Object object, FrameManager frameManager) {
44        FrameFormat format = ObjectFormat.fromObject(object, FrameFormat.TARGET_SIMPLE);
45        SimpleFrame result = new SimpleFrame(format, frameManager);
46        result.setObjectValue(object);
47        return result;
48    }
49
50    private void initWithFormat(FrameFormat format) {
51        final int count = format.getLength();
52        final int baseType = format.getBaseType();
53        switch (baseType) {
54            case FrameFormat.TYPE_BYTE:
55                mObject = new byte[count];
56                break;
57            case FrameFormat.TYPE_INT16:
58                mObject = new short[count];
59                break;
60            case FrameFormat.TYPE_INT32:
61                mObject = new int[count];
62                break;
63            case FrameFormat.TYPE_FLOAT:
64                mObject = new float[count];
65                break;
66            case FrameFormat.TYPE_DOUBLE:
67                mObject = new double[count];
68                break;
69            default:
70                mObject = null;
71                break;
72        }
73    }
74
75    @Override
76    protected boolean hasNativeAllocation() {
77        return false;
78    }
79
80    @Override
81    protected void releaseNativeAllocation() {
82    }
83
84    @Override
85    public Object getObjectValue() {
86        return mObject;
87    }
88
89    @Override
90    public void setInts(int[] ints) {
91        assertFrameMutable();
92        setGenericObjectValue(ints);
93    }
94
95    @Override
96    public int[] getInts() {
97        return (mObject instanceof int[]) ? (int[])mObject : null;
98    }
99
100    @Override
101    public void setFloats(float[] floats) {
102        assertFrameMutable();
103        setGenericObjectValue(floats);
104    }
105
106    @Override
107    public float[] getFloats() {
108        return (mObject instanceof float[]) ? (float[])mObject : null;
109    }
110
111    @Override
112    public void setData(ByteBuffer buffer, int offset, int length) {
113        assertFrameMutable();
114        setGenericObjectValue(ByteBuffer.wrap(buffer.array(), offset, length));
115    }
116
117    @Override
118    public ByteBuffer getData() {
119        return (mObject instanceof ByteBuffer) ? (ByteBuffer)mObject : null;
120    }
121
122    @Override
123    public void setBitmap(Bitmap bitmap) {
124        assertFrameMutable();
125        setGenericObjectValue(bitmap);
126    }
127
128    @Override
129    public Bitmap getBitmap() {
130        return (mObject instanceof Bitmap) ? (Bitmap)mObject : null;
131    }
132
133    private void setFormatObjectClass(Class objectClass) {
134        MutableFrameFormat format = getFormat().mutableCopy();
135        format.setObjectClass(objectClass);
136        setFormat(format);
137    }
138
139    @Override
140    protected void setGenericObjectValue(Object object) {
141        // Update the FrameFormat class
142        // TODO: Take this out! FrameFormats should not be modified and convenience formats used
143        // instead!
144        FrameFormat format = getFormat();
145        if (format.getObjectClass() == null) {
146            setFormatObjectClass(object.getClass());
147        } else if (!format.getObjectClass().isAssignableFrom(object.getClass())) {
148            throw new RuntimeException(
149                "Attempting to set object value of type '" + object.getClass() + "' on " +
150                "SimpleFrame of type '" + format.getObjectClass() + "'!");
151        }
152
153        // Set the object value
154        mObject = object;
155    }
156
157    @Override
158    public String toString() {
159        return "SimpleFrame (" + getFormat() + ")";
160    }
161}
162