M7350v1_en_gpl

base/include/private/media/AudioEffectShared.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_EFFECTCBASESHARED_H
+#define ANDROID_EFFECTCBASESHARED_H
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#include <utils/threads.h>
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+// Size of buffer used to exchange parameters between application and mediaserver processes.
+#define EFFECT_PARAM_BUFFER_SIZE 1024
+
+
+// Shared memory area used to exchange parameters between application and mediaserver
+// process.
+struct effect_param_cblk_t
+{
+                Mutex       lock;
+    volatile    uint32_t    clientIndex;    // Current read/write index for application
+    volatile    uint32_t    serverIndex;    // Current read/write index for mediaserver
+                uint8_t*    buffer;         // start of parameter buffer
+
+                effect_param_cblk_t()
+                    : lock(Mutex::SHARED), clientIndex(0), serverIndex(0) {}
+};
+
+
+// ----------------------------------------------------------------------------
+
+}; // namespace android
+
+#endif // ANDROID_EFFECTCBASESHARED_H

base/include/private/media/AudioTrackShared.h

@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_AUDIO_TRACK_SHARED_H
+#define ANDROID_AUDIO_TRACK_SHARED_H
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#include <utils/threads.h>
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+#define THREAD_PRIORITY_AUDIO_CLIENT (ANDROID_PRIORITY_AUDIO)
+// Maximum cumulated timeout milliseconds before restarting audioflinger thread
+#define MAX_STARTUP_TIMEOUT_MS  3000    // Longer timeout period at startup to cope with A2DP init time
+#define MAX_RUN_TIMEOUT_MS      1000
+#define WAIT_PERIOD_MS          10
+
+#define CBLK_UNDERRUN_MSK       0x0001
+#define CBLK_UNDERRUN_ON        0x0001  // underrun (out) or overrrun (in) indication
+#define CBLK_UNDERRUN_OFF       0x0000  // no underrun
+#define CBLK_DIRECTION_MSK      0x0002
+#define CBLK_DIRECTION_OUT      0x0002  // this cblk is for an AudioTrack
+#define CBLK_DIRECTION_IN       0x0000  // this cblk is for an AudioRecord
+#define CBLK_FORCEREADY_MSK     0x0004
+#define CBLK_FORCEREADY_ON      0x0004  // track is considered ready immediately by AudioFlinger
+#define CBLK_FORCEREADY_OFF     0x0000  // track is ready when buffer full
+#define CBLK_INVALID_MSK        0x0008
+#define CBLK_INVALID_ON         0x0008  // track buffer is invalidated by AudioFlinger:
+#define CBLK_INVALID_OFF        0x0000  // must be re-created
+#define CBLK_DISABLED_MSK       0x0010
+#define CBLK_DISABLED_ON        0x0010  // track disabled by AudioFlinger due to underrun:
+#define CBLK_DISABLED_OFF       0x0000  // must be re-started
+
+struct audio_track_cblk_t
+{
+
+    // The data members are grouped so that members accessed frequently and in the same context
+    // are in the same line of data cache.
+                Mutex       lock;
+                Condition   cv;
+    volatile    uint32_t    user;
+    volatile    uint32_t    server;
+                uint32_t    userBase;
+                uint32_t    serverBase;
+                void*       buffers;
+                uint32_t    frameCount;
+                // Cache line boundary
+                uint32_t    loopStart;
+                uint32_t    loopEnd;
+                int         loopCount;
+    volatile    union {
+                    uint16_t    volume[2];
+                    uint32_t    volumeLR;
+                };
+                uint32_t    sampleRate;
+                // NOTE: audio_track_cblk_t::frameSize is not equal to AudioTrack::frameSize() for
+                // 8 bit PCM data: in this case,  mCblk->frameSize is based on a sample size of
+                // 16 bit because data is converted to 16 bit before being stored in buffer
+
+                uint32_t    frameSize;
+                uint8_t     padding;
+                uint8_t     channelCount;
+                uint16_t    flags;
+
+                uint16_t    bufferTimeoutMs; // Maximum cumulated timeout before restarting audioflinger
+                uint16_t    waitTimeMs;      // Cumulated wait time
+
+                uint16_t    sendLevel;
+                uint16_t    reserved;
+                // Cache line boundary (32 bytes)
+                            audio_track_cblk_t();
+                uint32_t    stepUser(uint32_t frameCount);
+                bool        stepServer(uint32_t frameCount);
+                void*       buffer(uint32_t offset) const;
+                uint32_t    framesAvailable();
+                uint32_t    framesAvailable_l();
+                uint32_t    framesReady();
+};
+
+
+// ----------------------------------------------------------------------------
+
+}; // namespace android
+
+#endif // ANDROID_AUDIO_TRACK_SHARED_H

base/include/private/media/VideoFrame.h

@@ -0,0 +1,128 @@
+/*
+**
+** Copyright (C) 2008 The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#ifndef ANDROID_VIDEO_FRAME_H
+#define ANDROID_VIDEO_FRAME_H
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <utils/Log.h>
+
+namespace android {
+
+// A simple buffer to hold binary data
+class MediaAlbumArt 
+{
+public:
+    MediaAlbumArt(): mSize(0), mData(0) {}
+
+    explicit MediaAlbumArt(const char* url) {
+        mSize = 0;
+        mData = NULL;
+        FILE *in = fopen(url, "r");
+        if (!in) {
+            return;
+        }
+        fseek(in, 0, SEEK_END);
+        mSize = ftell(in);  // Allocating buffer of size equals to the external file size.
+        if (mSize == 0 || (mData = new uint8_t[mSize]) == NULL) {
+            fclose(in);
+            if (mSize != 0) {
+                mSize = 0;
+            }
+            return;
+        }
+        rewind(in);
+        if (fread(mData, 1, mSize, in) != mSize) {  // Read failed.
+            delete[] mData;
+            mData = NULL;
+            mSize = 0;
+            return;
+        }
+        fclose(in);
+    }
+
+    MediaAlbumArt(const MediaAlbumArt& copy) { 
+        mSize = copy.mSize; 
+        mData = NULL;  // initialize it first 
+        if (mSize > 0 && copy.mData != NULL) {
+           mData = new uint8_t[copy.mSize];
+           if (mData != NULL) {
+               memcpy(mData, copy.mData, mSize);
+           } else {
+               mSize = 0;
+           }
+        }
+    }
+
+    ~MediaAlbumArt() {
+        if (mData != 0) {
+            delete[] mData;
+        }
+    }
+
+    // Intentional public access modifier:
+    // We have to know the internal structure in order to share it between
+    // processes?
+    uint32_t mSize;            // Number of bytes in mData
+    uint8_t* mData;            // Actual binary data
+};
+
+// Represents a color converted (RGB-based) video frame
+// with bitmap pixels stored in FrameBuffer
+class VideoFrame
+{
+public:
+    VideoFrame(): mWidth(0), mHeight(0), mDisplayWidth(0), mDisplayHeight(0), mSize(0), mData(0) {}
+ 
+    VideoFrame(const VideoFrame& copy) {
+        mWidth = copy.mWidth;
+        mHeight = copy.mHeight;
+        mDisplayWidth = copy.mDisplayWidth;
+        mDisplayHeight = copy.mDisplayHeight;
+        mSize = copy.mSize;
+        mData = NULL;  // initialize it first
+        if (mSize > 0 && copy.mData != NULL) {
+            mData = new uint8_t[mSize];
+            if (mData != NULL) {
+                memcpy(mData, copy.mData, mSize);
+            } else {
+                mSize = 0;
+            }
+        }
+    }
+
+    ~VideoFrame() {
+        if (mData != 0) {
+            delete[] mData;
+        }
+    }
+
+    // Intentional public access modifier:
+    uint32_t mWidth;
+    uint32_t mHeight;
+    uint32_t mDisplayWidth;
+    uint32_t mDisplayHeight;
+    uint32_t mSize;            // Number of bytes in mData
+    uint8_t* mData;            // Actual binary data
+    int32_t  mRotationAngle;   // rotation angle, clockwise
+};
+
+}; // namespace android
+
+#endif // ANDROID_VIDEO_FRAME_H