Code drop from //branches/cupcake/...@124589

2 files changed, 151 insertions, 12 deletions

diff --git a/include/private/media/AudioTrackShared.h b/include/private/media/AudioTrackShared.h
index 1878f3c..72ed281 100644
--- a/include/private/media/AudioTrackShared.h
+++ b/include/private/media/AudioTrackShared.h
@@ -31,29 +31,41 @@ namespace android {
 
 struct audio_track_cblk_t
 {
-    enum {
-        SEQUENCE_MASK   = 0xFFFFFF00,
-        BUFFER_MASK     = 0x000000FF
-    };
 
+    // 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;
                 };
                 uint16_t    sampleRate;
-                uint16_t    reserved;
-
-                void*       buffers;
-                size_t      size;
-            
+                uint16_t    channels;
+                int16_t     flowControlFlag; // underrun (out) or overrrun (in) indication
+                uint8_t     out;        // out equals 1 for AudioTrack and 0 for AudioRecord
+                uint8_t     forceReady; 
+                // Padding ensuring that data buffer starts on a cache line boundary (32 bytes). 
+                // See AudioFlinger::TrackBase constructor
+                int32_t     Padding[4];
+                
                             audio_track_cblk_t();
-                uint32_t    stepUser(int bufferCount);
-                bool        stepServer(int bufferCount);
-                void*       buffer(int id) const;
+                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();
 };
 
 
diff --git a/include/private/media/VideoFrame.h b/include/private/media/VideoFrame.h
new file mode 100644
index 0000000..9c35274
--- /dev/null
+++ b/include/private/media/VideoFrame.h
@@ -0,0 +1,127 @@
+/*
+**
+** 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
+};
+
+}; // namespace android
+
+#endif // ANDROID_VIDEO_FRAME_H