移植FFmpeg到Android ics

2. /* 
4. * Copyright (C) 2009 The Android Open Source Project 
5. * 
6. * Licensed under the Apache License, Version 2.0 (the "License"); 
7. * you may not use this file except in compliance with the License. 
8. * You may obtain a copy of the License at 
9. * 
10. * http://www.apache.org/licenses/LICENSE-2.0 
11. * 
12. * Unless required by applicable law or agreed to in writing, software 
13. * distributed under the License is distributed on an "AS IS" BASIS, 
14. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
15. * See the License for the specific language governing permissions and 
16. * limitations under the License. 
17. */  
18. #include <android/surface.h>   
19. #include <surfaceflinger/Surface.h>   
20. #include <utils/Log.h>   
21. #include <SkBitmap.h>   
22. #include <SkCanvas.h>   
23.   
24. #define TAG "SurfaceWrapper"   
25.   
26. using namespace android;  
27.   
28. static Surface *sSurface;  
29. static SkBitmap sBitmapClient;  
30. static SkBitmap sBitmapSurface;  
31.   
32. static Surface *getNativeSurface (JNIEnv * env, jobject jsurface)  
33. {  
34.     jclass clazz = env->FindClass ("android/view/Surface");  
35.     jfieldID field_surface = env->GetFieldID (clazz, "mNativeSurface", "I");  
36.     if (field_surface == NULL)  
37.     {  
38.         return NULL;  
39.     }  
40.     return (Surface *) env->GetIntField (jsurface, field_surface);  
41. }  
42.   
43. static int initBitmap (SkBitmap * bitmap, int format, int width, int height, bool allocPixels)  
44. {  
45.     switch (format)  
46.     {  
47.     case PIXEL_FORMAT_RGBA_8888:  
48.         bitmap->setConfig (SkBitmap::kARGB_8888_Config, width, height);  
49.         break;  
50.   
51.     case PIXEL_FORMAT_RGBA_4444:  
52.         bitmap->setConfig (SkBitmap::kARGB_4444_Config, width, height);  
53.         break;  
54.   
55.     case PIXEL_FORMAT_RGB_565:  
56.         bitmap->setConfig (SkBitmap::kRGB_565_Config, width, height);  
57.         break;  
58.   
59.     case PIXEL_FORMAT_A_8:  
60.         bitmap->setConfig (SkBitmap::kA8_Config, width, height);  
61.         break;  
62.   
63.     default:  
64.         bitmap->setConfig (SkBitmap::kNo_Config, width, height);  
65.         break;  
66.     }  
67.   
68.     if (allocPixels)  
69.     {  
70.         bitmap->setIsOpaque (true);  
71. //-- alloc array of pixels   
72.         if (!bitmap->allocPixels ())  
73.         {  
74.             return -1;  
75.         }  
76.     }  
77.     return 0;  
78. }  
79.   
80. int AndroidSurface_register (JNIEnv * env, jobject jsurface)  
81. {  
82.     __android_log_print (ANDROID_LOG_INFO, TAG, "registering video surface");  
83.   
84.     sSurface = getNativeSurface (env, jsurface);  
85.     if (sSurface == NULL)  
86.     {  
87.         return ANDROID_SURFACE_RESULT_JNI_EXCEPTION;  
88.     }  
89.   
90.     __android_log_print (ANDROID_LOG_INFO, TAG, "registered");  
91.   
92.     return ANDROID_SURFACE_RESULT_SUCCESS;  
93. }  
94.   
95. int AndroidSurface_getPixels (int width, int height, void **pixels)  
96. {  
97.     __android_log_print (ANDROID_LOG_INFO, TAG, "getting surface's pixels %ix%i", width, height);  
98.     if (sSurface == NULL)  
99.     {  
100.         return ANDROID_SURFACE_RESULT_JNI_EXCEPTION;  
101.     }  
102.     if (initBitmap (&sBitmapClient, PIXEL_FORMAT_RGB_565, width, height, true) < 0)  
103.     {  
104.         return ANDROID_SURFACE_RESULT_COULDNT_INIT_BITMAP_CLIENT;  
105.     }  
106.     *pixels = sBitmapClient.getPixels ();  
107.     __android_log_print (ANDROID_LOG_INFO, TAG, "getted");  
108.     return ANDROID_SURFACE_RESULT_SUCCESS;  
109. }  
110.   
111. static void doUpdateSurface ()  
112. {  
113.     SkCanvas canvas (sBitmapSurface);  
114.     SkRect surface_sBitmapClient;  
115.     SkRect surface_sBitmapSurface;  
116.     SkMatrix matrix;  
117.   
118.     surface_sBitmapSurface.set (0, 0, sBitmapSurface.width (), sBitmapSurface.height ());  
119.     surface_sBitmapClient.set (0, 0, sBitmapClient.width (), sBitmapClient.height ());  
120.     matrix.setRectToRect (surface_sBitmapClient, surface_sBitmapSurface, SkMatrix::kFill_ScaleToFit);  
121.   
122.     canvas.drawBitmapMatrix (sBitmapClient, matrix);  
123. }  
124.   
125. static int prepareSurfaceBitmap (Surface::SurfaceInfo * info)  
126. {  
127.     if (initBitmap (&sBitmapSurface, info->format, info->w, info->h, false) < 0)  
128.     {  
129.         return -1;  
130.     }  
131.     sBitmapSurface.setPixels (info->bits);  
132.     return 0;  
133. }  
134.   
135. int AndroidSurface_updateSurface ()  
136. {  
137.     static Surface::SurfaceInfo surfaceInfo;  
138.     if (sSurface == NULL)  
139.     {  
140.         return ANDROID_SURFACE_RESULT_JNI_EXCEPTION;  
141.     }  
142.   
143.     if (!Surface::isValid (sSurface))  
144.     {  
145.         return ANDROID_SURFACE_RESULT_NOT_VALID;  
146.     }  
147.     if (sSurface->lock (&surfaceInfo,NULL) < 0)  
148.     {  
149.         return ANDROID_SURFACE_RESULT_COULDNT_LOCK;  
150.     }  
151.   
152.     if (prepareSurfaceBitmap (&surfaceInfo) < 0)  
153.     {  
154.         return ANDROID_SURFACE_RESULT_COULDNT_INIT_BITMAP_SURFACE;  
155.     }  
156.   
157.     doUpdateSurface ();  
158.   
159.     if (sSurface->unlockAndPost () < 0)  
160.     {  
161.         return ANDROID_SURFACE_RESULT_COULDNT_UNLOCK_AND_POST;  
162.     }  
163.     return ANDROID_SURFACE_RESULT_SUCCESS;  
164. }  
165.   
166. int AndroidSurface_unregister ()  
167. {  
168.     __android_log_print (ANDROID_LOG_INFO, TAG, "unregistering video surface");  
169.     __android_log_print (ANDROID_LOG_INFO, TAG, "unregistered");  
170.     return ANDROID_SURFACE_RESULT_SUCCESS;  
171. }  

更多Android相关信息见Android 专题页面 http://www.bkjia.com/topicnews.aspx?tid=11