Recherche avancée

Sur d’autres sites (4050)

• Investigating Steam for Linux

  1er mars 2013, par Multimedia Mike — Game Hacking

  Valve recently released the final, public version of their Steam client for Linux, and the Linux world rejoiced. At least, it probably did. The announcement was 2 weeks ago on Valentine’s Day and I had other things on my mind, so I missed any fanfare. When framed in this manner, the announcement timing becomes suspect– it’s as though Linux enthusiasts would have plenty of time that day or something.

  
  
  

  Taming the Frontier
  Speculation about a Linux Steam client had been kicking around for nearly as long as Steam has existed. However, sometime last year, the rumors became more substantive.

  I naturally wondered how to port something like Steam to Linux. I have some experience with trying to make a necessarily binary-only program that runs on Linux. I’m fairly well-versed in the assorted technical challenges that one might face when attempting such a feat. Because of this, whenever I hear rumors that a company might be entertaining the notion of porting a major piece of proprietary software to Linux, my instinctive reflex is, “What ?! Why, you fools ?! Save yourselves !”

  At least, that’s how it used to be. The proposal of developing a proprietary binary for Linux has been rendered considerably less insane by a few developments, for example :

  1. The rise of Ubuntu Linux as a quasi de facto standard for desktop Linux computing
  2. The increasing homogeneity in personal desktop computing technology

  What I would like to know is how the Steam client runs on Linux. Does it rely on any libraries being present on the system ? Or does it bring its own ? The latter is a trick that proprietary programs can use– transport all of the shared libraries that the main program binary depends upon, install them someplace out of the way on the filesystem, probably in /opt, and then make the main program a shell script which sets a preload path to rely on the known quantity libraries instead of the copies already on the system.

  Downloading and Installing the Client
  For this exercise, I installed x86_64 desktop Ubuntu 12.04 Linux on a l33t gaming rig that was totally top of the line about 5 years ago, and that someone didn’t want anymore and handed down to me recently. So it should be ideal for this project.

  At first, I was blown away– the Linux client is in a .deb package that is less than 2 MB large. I unpacked the steam.deb file and found a bunch of support libraries — mostly X11 and standard C/C++ runtimes. Just as I suspected. Still, I can’t believe how small the thing is. However, my amazement quickly abated when I actually ran Steam and saw this :

  
  
  

  So it turns out steam.db is just the installer program which immediately proceeds to download an additional 160+ MB of data. So there’s actually a lot more information to possibly sift through.
  
  Another component of the installation is to basically run a big ‘apt-get install’ command to make sure a bunch of required packages are installed :

  
  
  

  After all these installation steps, the client was ready to run. However, whenever I tried to do so, I got this dialog which would cause Steam to close when the dialog was dismissed.

  
  
  

  Not a huge deal ; later NVIDIA drivers are fairly straightforward to install on Ubuntu Linux. After a few minutes of downloading, installing and restarting X, Steam ran with minimal complaint (it still had some issue regarding the video drivers but didn’t seem to consider it a deal-breaker).

  Using Steam on Linux

  So here’s Steam running on Linux :

  
  
  

  If you have experience with using Steam on Windows or Mac, you might observe that it looks exactly the same. I don’t have a very expansive library of games (I only started using Steam because purchasing a few computer components a few years ago entitled me to some free Steam downloads of some of the games on the list in the screenshot). I didn’t really expect any of the games to have Linux versions yet, but it turns out that the indie darling FTL : Faster Than Light has been ported to Linux. FTL was a much-heralded Kickstarter success story and sounded like something I wanted to support. I purchased this from Steam shortly after its release last year and was able to download the Linux version at no additional cost with a single click.

  It runs natively on Linux (note the Ubuntu desktop window decorations) :

  
  
  

  You might notice from the main Steam client that, despite purchasing FTL about a 1/2 year ago and starting it up at least a 1/2 dozen times, I haven’t really invested a whole lot of time into it. I only managed to get about 2 minutes further this time :

  
  
  

  What can I say ? This game just bores me to tears. It’s frustrating because I know that this is one of the cool games that all real gamers are supposed to like, but I practically catch myself nodding off every time I try to run through the tutorial. It’s strange to think that I’ve invested far more time into games that offer considerably less stimulation. That’s probably because I had far more free time compared to gaming options during those times.

  But that’s neither here nor there. We’ll file this under “games that aren’t for me.” I’m glad that people like FTL and a little indie underdog has met with such success. And I’m pleased that Steam on Linux works. It’s native and the games are also native, which is all quite laudable (there was speculation that everything would just be running on top of a Wine layer).

  Deeper Analysis
  So I set out wondering how Steam was able to create a proprietary program that would satisfy a large enough cross-section of Linux users (i.e., on different platforms and distros). Answer : well, they didn’t, per the stated requirements. The installation is only tuned to work on Ubuntu 12.04. However, it works on both 32- and 64-bit platforms, the only 2 desktop CPU platforms that matter these days (unless ARM somehow makes inroads on the desktop). The Steam client is quite clearly an x86_32 binary– look at the terminal screenshot above and observe that it’s downloading all :i386 support libraries.

  The file /usr/bin/steam isn’t a binary but a launcher shell script (something you’ll also see if you investigate /usr/bin/firefox on a Linux system). Here’s an interesting tidbit :

  function detect_platform()
  
    # Maybe be smarter someday
    # Right now this is the only platform we have a bootstrap for, so hard-code it.
    echo ubuntu12_32
  
  

  I wager that it’s possible to get Steam running on other distributions, it probably just takes a little more effort (assuming that Steam doesn’t put too much effort into thwarting such attempts).

  As for the FTL game, it comes with binaries and libraries for both x86_32 and x86_64. So, good work to the dev team for creating and testing both versions. FTL also distributes versions of the libraries it expects to work with.

  I suspect that the Steam client overall is largely a WWW rendering engine underneath the covers. That would help explain how Valve is able to achieve such a consistent look and feel, not only across OS platforms, but also through a web browser. When I browse the Steam store through Google Chrome, it looks and feels exactly like the native desktop client. When I first thought of how someone could port Steam to Linux, I immediately wondered about how they would do the UI.

  A little Googling for “steam uses webkit” (just a hunch) confirms my hypothesis.

• Fixed an issue with percent-based heights in iOS

  10 mars 2013, par jackmoore

  m colorbox.jquery.json m component.json m i18n/jquery.colorbox-fr.js m jquery.colorbox-min.js m jquery.colorbox.js Fixed an issue with percent-based heights in iOS Fixed an issue with ajax requests being applied at the wrong (...)

• Android FFmpeg Video Player

  11 mars 2013, par Dilip

  I want to play video using FFmpeg for this have used some code,But it open file but not drawing frames thowing Unhandled page fault exception.

  Java Code :

  public class MainActivity extends Activity {
  
      private static native void openFile();
  
  
  
      private static native void drawFrame(Bitmap bitmap);
  
  
  
      private static native void drawFrameAt(Bitmap bitmap, int secs);
  
  
  
      private Bitmap mBitmap;
  
      private int mSecs = 0;
  
  
  
      static {
  
          System.loadLibrary("ffmpegutils");
  
      }
  
  
  
      /** Called when the activity is first created. */
  
      @Override
  
      public void onCreate(Bundle savedInstanceState) {
  
          super.onCreate(savedInstanceState);
  
          // setContentView(new VideoView(this));
  
          setContentView(R.layout.main);
  
  
  
          mBitmap = Bitmap.createBitmap(320, 240, Bitmap.Config.ARGB_8888);
  
          openFile();
  
  
  
          Button btn = (Button) findViewById(R.id.frame_adv);
  
          btn.setOnClickListener(new OnClickListener() {
  
              public void onClick(View v) {
  
                  try {
  
                      drawFrame(mBitmap);
  
                      ImageView i = (ImageView) findViewById(R.id.frame);
  
                      i.setImageBitmap(mBitmap);
  
                  } catch (Exception e) {
  
                      e.printStackTrace();
  
                  }
  
              }
  
          });
  
  }}

  Jni code :

  #include 
  
  #include 
  
  #include 
  
  #include <android></android>log.h>
  
  #include <android></android>bitmap.h>
  
  
  
  #include <libavcodec></libavcodec>avcodec.h>
  
  #include <libavformat></libavformat>avformat.h>
  
  #include <libswscale></libswscale>swscale.h>
  
  
  
  #define  LOG_TAG    "FFMPEGSample"
  
  #define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
  
  #define  LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
  
  
  
  /* Cheat to keep things simple and just use some globals. */
  
  AVFormatContext *pFormatCtx;
  
  AVCodecContext *pCodecCtx;
  
  AVFrame *pFrame;
  
  AVFrame *pFrameRGB;
  
  int videoStream;
  
  
  
  /*
  
   * Write a frame worth of video (in pFrame) into the Android bitmap
  
   * described by info using the raw pixel buffer.  It&#39;s a very inefficient
  
   * draw routine, but it&#39;s easy to read. Relies on the format of the
  
   * bitmap being 8bits per color component plus an 8bit alpha channel.
  
   */
  
  
  
  static void fill_bitmap(AndroidBitmapInfo* info, void *pixels, AVFrame *pFrame) {
  
      uint8_t *frameLine;
  
  
  
      int yy;
  
      for (yy = 0; yy &lt; info->height; yy++) {
  
          uint8_t* line = (uint8_t*) pixels;
  
          frameLine = (uint8_t *) pFrame->data[0] + (yy * pFrame->linesize[0]);
  
  
  
          int xx;
  
          for (xx = 0; xx &lt; info->width; xx++) {
  
              int out_offset = xx * 4;
  
              int in_offset = xx * 3;
  
              line[out_offset] = frameLine[in_offset];
  
              line[out_offset + 1] = frameLine[in_offset + 1];
  
              line[out_offset + 2] = frameLine[in_offset + 2];
  
              line[out_offset + 3] = 0;
  
          }
  
          pixels = (char*) pixels + info->stride;
  
      }
  
  }
  
  
  
  void Java_com_churnlabs_ffmpegsample_MainActivity_openFile(JNIEnv * env,
  
          jobject this) {
  
      int ret;
  
      int err;
  
      int i;
  
      AVCodec *pCodec;
  
      uint8_t *buffer;
  
      int numBytes;
  
  
  
      av_register_all();
  
      LOGE("Registered formats***********************************");
  
      err = av_open_input_file(&amp;pFormatCtx, "file:///mnt/sdcard/android.3gp",
  
              NULL, 0, NULL);
  
      LOGE("Called open file***************************************************");
  
      if (err != 0) {
  
          LOGE(
  
                  "Couldn&#39;t open file****************************************************");
  
          return;
  
      }
  
      LOGE(
  
              "Opened file***********************************************************");
  
  
  
      if (av_find_stream_info(pFormatCtx) &lt; 0) {
  
          LOGE(
  
                  "Unable to get stream info*****************************************");
  
          return;
  
      }
  
  
  
      videoStream = -1;
  
      for (i = 0; i &lt; pFormatCtx->nb_streams; i++) {
  
          if (pFormatCtx->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO) {
  
              videoStream = i;
  
              break;
  
          }
  
      }
  
      if (videoStream == -1) {
  
          LOGE("Unable to find video stream");
  
          return;
  
      }
  
  
  
      LOGI("Video stream is [%d]", videoStream);
  
  
  
      pCodecCtx = pFormatCtx->streams[videoStream]->codec;
  
  
  
      pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
  
      if (pCodec == NULL) {
  
          LOGE("Unsupported codec**********************************************");
  
          return;
  
      }
  
  
  
      if (avcodec_open(pCodecCtx, pCodec) &lt; 0) {
  
          LOGE("Unable to open codec***************************************");
  
          return;
  
      }
  
  
  
      pFrame = avcodec_alloc_frame();
  
      pFrameRGB = avcodec_alloc_frame();
  
      LOGI("Video size is [%d x %d]", pCodecCtx->width, pCodecCtx->height);
  
  
  
      numBytes = avpicture_get_size(PIX_FMT_RGB24, pCodecCtx->width,
  
              pCodecCtx->height);
  
      buffer = (uint8_t *) av_malloc(numBytes * sizeof(uint8_t));
  
  
  
      avpicture_fill((AVPicture *) pFrameRGB, buffer, PIX_FMT_RGB24,
  
              pCodecCtx->width, pCodecCtx->height);
  
  }
  
  
  
  void Java_com_churnlabs_ffmpegsample_MainActivity_drawFrame(JNIEnv * env,
  
          jobject this, jstring bitmap) {
  
      AndroidBitmapInfo info;
  
      void* pixels;
  
      int ret;
  
  
  
      int err;
  
      int i;
  
      int frameFinished = 0;
  
      AVPacket packet;
  
      static struct SwsContext *img_convert_ctx;
  
      int64_t seek_target;
  
  
  
      if ((ret = AndroidBitmap_getInfo(env, bitmap, &amp;info)) &lt; 0) {
  
          LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);
  
          return;
  
      }
  
      LOGE(
  
              "Checked on the bitmap*************************************************");
  
  
  
      if ((ret = AndroidBitmap_lockPixels(env, bitmap, &amp;pixels)) &lt; 0) {
  
          LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
  
      }
  
      LOGE(
  
              "Grabbed the pixels*******************************************************");
  
  
  
      i = 0;
  
      while ((i == 0) &amp;&amp; (av_read_frame(pFormatCtx, &amp;packet) >= 0)) {
  
          if (packet.stream_index == videoStream) {
  
              avcodec_decode_video2(pCodecCtx, pFrame, &amp;frameFinished, &amp;packet);
  
  
  
              if (frameFinished) {
  
                  LOGE("packet pts %llu", packet.pts);
  
                  // This is much different than the tutorial, sws_scale
  
                  // replaces img_convert, but it&#39;s not a complete drop in.
  
                  // This version keeps the image the same size but swaps to
  
                  // RGB24 format, which works perfect for PPM output.
  
                  int target_width = 320;
  
                  int target_height = 240;
  
                  img_convert_ctx = sws_getContext(pCodecCtx->width,
  
                          pCodecCtx->height, pCodecCtx->pix_fmt, target_width,
  
                          target_height, PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL,
  
                          NULL);
  
                  if (img_convert_ctx == NULL) {
  
                      LOGE("could not initialize conversion context\n");
  
                      return;
  
                  }
  
                  sws_scale(img_convert_ctx,
  
                          (const uint8_t* const *) pFrame->data, pFrame->linesize,
  
                          0, pCodecCtx->height, pFrameRGB->data,
  
                          pFrameRGB->linesize);
  
  
  
                  // save_frame(pFrameRGB, target_width, target_height, i);
  
                  fill_bitmap(&amp;info, pixels, pFrameRGB);
  
                  i = 1;
  
              }
  
          }
  
          av_free_packet(&amp;packet);
  
      }
  
  
  
      AndroidBitmap_unlockPixels(env, bitmap);
  
  }
  
  
  
  int seek_frame(int tsms) {
  
      int64_t frame;
  
  
  
      frame = av_rescale(tsms, pFormatCtx->streams[videoStream]->time_base.den,
  
              pFormatCtx->streams[videoStream]->time_base.num);
  
      frame /= 1000;
  
  
  
      if (avformat_seek_file(pFormatCtx, videoStream, 0, frame, frame,
  
              AVSEEK_FLAG_FRAME) &lt; 0) {
  
          return 0;
  
      }
  
  
  
      avcodec_flush_buffers(pCodecCtx);
  
  
  
      return 1;
  
  }

  Log Trace

   0): <6>AUO_TOUCH: ts_irqHandler: before disable_irq()
  
  D/PrintK  (   57): <6>AUO_TOUCH: ts_irqWorkHandler: P1(313,750),P2(0,0)
  
  D/PrintK  (    0): <6>AUO_TOUCH: ts_irqHandler: before disable_irq()
  
  D/PrintK  (   57): <6>AUO_TOUCH: ts_irqWorkHandler: P1(0,0),P2(0,0)
  
  E/FFMPEGSample( 2882): Checked on the bitmap*************************************************
  
  E/FFMPEGSample( 2882): Grabbed the pixels*******************************************************
  
  E/FFMPEGSample( 2882): packet pts 0
  
  F/PrintK  ( 2882): <2>Exception!!! bs.ffmpegsample: unhandled page fault (11) at 0x0000000c, code 0x017
  
  F/PrintK  ( 2882): <2>Exception!!! bs.ffmpegsample: unhandled page fault (11) at 0x0000000c, code 0x017
  
  I/DEBUG   (   86): *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
  
  F/DEBUG   (   86): *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
  
  I/DEBUG   (   86): Build fingerprint: 'dell/streak/streak/8x50:2.2.2/FRG83G/eng.cmbuild.20110317.163900:user/release-keys'
  
  I/DEBUG   (   86): Exception!!! pid: 2882, tid: 2882  >>> com.churnlabs.ffmpegsample <<<
  
  F/DEBUG   (   86): Exception!!! pid: 2882, tid: 2882  >>> com.churnlabs.ffmpegsample <<<
  
  I/DEBUG   (   86): signal 11 (SIGSEGV), fault addr 0000000c
  
  F/DEBUG   (   86): signal 11 (SIGSEGV), fault addr 0000000c
  
  I/DEBUG   (   86):  r0 00000070  r1 00000000  r2 0024fca8  r3 afd42328
  
  F/DEBUG   (   86):  r0 00000070  r1 00000000  r2 0024fca8  r3 afd42328
  
  I/DEBUG   (   86):  r4 00000000  r5 00000000  r6 0000062c  r7 0000a000
  
  F/DEBUG   (   86):  r4 00000000  r5 00000000  r6 0000062c  r7 0000a000
  
  I/DEBUG   (   86):  r8 be9794f0  r9 428ab9d8  10 00000003  fp be979830
  
  F/DEBUG   (   86):  r8 be9794f0  r9 428ab9d8  10 00000003  fp be979830
  
  I/DEBUG   (   86):  ip ffffff90  sp be979448  lr afd0c633  pc afd0c320  cpsr 80000030
  
  F/DEBUG   (   86):  ip ffffff90  sp be979448  lr afd0c633  pc afd0c320  cpsr 80000030
  
  I/DEBUG   (   86):  d0  6472656767756265  d1  0000000000000000
  
  I/DEBUG   (   86):  d2  0000000000000000  d3  0000000044480000
  
  I/DEBUG   (   86):  d4  8000000000000000  d5  000000003f800000
  
  I/DEBUG   (   86):  d6  0000000000000000  d7  4448000043f00000
  
  I/DEBUG   (   86):  d8  0000000000000000  d9  0000000000000000
  
  I/DEBUG   (   86):  d10 0000000000000000  d11 0000000000000000
  
  I/DEBUG   (   86):  d12 0000000000000000  d13 0000000000000000
  
  I/DEBUG   (   86):  d14 0000000000000000  d15 0000000000000000
  
  I/DEBUG   (   86):  d16 0000000000000000  d17 0000000000000000
  
  I/DEBUG   (   86):  d18 0000000000000000  d19 0000000000000000
  
  I/DEBUG   (   86):  d20 3ff0000000000000  d21 8000000000000000
  
  I/DEBUG   (   86):  d22 0000000000000000  d23 0000000500010004
  
  I/DEBUG   (   86):  d24 0101010101010101  d25 0000000000000000
  
  I/DEBUG   (   86):  d26 0000000000000000  d27 0000000000000000
  
  I/DEBUG   (   86):  d28 0000000000000000  d29 3ff0000000000000
  
  I/DEBUG   (   86):  d30 0000000000000000  d31 3ff0000000000000
  
  I/DEBUG   (   86):  scr 80000012
  
  I/DEBUG   (   86): 
  
  I/DEBUG   (   86):          #00  pc 0000c320  /system/lib/libc.so
  
  F/DEBUG   (   86):          #00  pc 0000c320  /system/lib/libc.so
  
  I/DEBUG   (   86):          #01  pc 0000c62e  /system/lib/libc.so
  
  F/DEBUG   (   86):          #01  pc 0000c62e  /system/lib/libc.so
  
  I/DEBUG   (   86):          #02  pc 0000cd3e  /system/lib/libc.so
  
  F/DEBUG   (   86):          #02  pc 0000cd3e  /system/lib/libc.so
  
  I/DEBUG   (   86):          #03  pc 0002d2c4  /system/lib/libskia.so
  
  F/DEBUG   (   86):          #03  pc 0002d2c4  /system/lib/libskia.so
  
  I/DEBUG   (   86):          #04  pc 000693ec  /system/lib/libskia.so
  
  F/DEBUG   (   86):          #04  pc 000693ec  /system/lib/libskia.so
  
  I/DEBUG   (   86):          #05  pc 00064d70  /system/lib/libskia.so
  
  F/DEBUG   (   86):          #05  pc 00064d70  /system/lib/libskia.so
  
  I/DEBUG   (   86):          #06  pc 0004dea8  /system/lib/libandroid_runtime.so
  
  F/DEBUG   (   86):          #06  pc 0004dea8  /system/lib/libandroid_runtime.so
  
  I/DEBUG   (   86):          #07  pc 00016df4  /system/lib/libdvm.so
  
  F/DEBUG   (   86):          #07  pc 00016df4  /system/lib/libdvm.so
  
  I/DEBUG   (   86):          #08  pc 00042904  /system/lib/libdvm.so
  
  F/DEBUG   (   86):          #08  pc 00042904  /system/lib/libdvm.so
  
  I/DEBUG   (   86):          #09  pc 0001bd58  /system/lib/libdvm.so
  
  F/DEBUG   (   86):          #09  pc 0001bd58  /system/lib/libdvm.so
  
  I/DEBUG   (   86):          #10  pc 00022550  /system/lib/libdvm.so
  
  F/DEBUG   (   86):          #10  pc 00022550  /system/lib/libdvm.so
  
  I/DEBUG   (   86):          #11  pc 000213f0  /system/lib/libdvm.so
  
  F/DEBUG   (   86):          #11  pc 000213f0  /system/lib/libdvm.so
  
  I/DEBUG   (   86):          #12  pc 00058c4a  /system/lib/libdvm.so
  
  F/DEBUG   (   86):          #12  pc 00058c4a  /system/lib/libdvm.so
  
  I/DEBUG   (   86):          #13  pc 00060e72  /system/lib/libdvm.so
  
  F/DEBUG   (   86):          #13  pc 00060e72  /system/lib/libdvm.so
  
  I/DEBUG   (   86):          #14  pc 0001bd58  /system/lib/libdvm.so
  
  F/DEBUG   (   86):          #14  pc 0001bd58  /system/lib/libdvm.so
  
  I/DEBUG   (   86):          #15  pc 00022550  /system/lib/libdvm.so
  
  F/DEBUG   (   86):          #15  pc 00022550  /system/lib/libdvm.so
  
  I/DEBUG   (   86):          #16  pc 000213f0  /system/lib/libdvm.so
  
  F/DEBUG   (   86):          #16  pc 000213f0  /system/lib/libdvm.so
  
  I/DEBUG   (   86):          #17  pc 00058a90  /system/lib/libdvm.so
  
  F/DEBUG   (   86):          #17  pc 00058a90  /system/lib/libdvm.so
  
  I/DEBUG   (   86):          #18  pc 0004525e  /system/lib/libdvm.so
  
  F/DEBUG   (   86):          #18  pc 0004525e  /system/lib/libdvm.so
  
  I/DEBUG   (   86):          #19  pc 0002e574  /system/lib/libandroid_runtime.so
  
  F/DEBUG   (   86):          #19  pc 0002e574  /system/lib/libandroid_runtime.so
  
  I/DEBUG   (   86):          #20  pc 0002f5f6  /system/lib/libandroid_runtime.so
  
  F/DEBUG   (   86):          #20  pc 0002f5f6  /system/lib/libandroid_runtime.so
  
  I/DEBUG   (   86):          #21  pc 00008ca8  /system/bin/app_process
  
  F/DEBUG   (   86):          #21  pc 00008ca8  /system/bin/app_process
  
  I/DEBUG   (   86):          #22  pc 0000d3d0  /system/lib/libc.so
  
  F/DEBUG   (   86):          #22  pc 0000d3d0  /system/lib/libc.so
  
  I/DEBUG   (   86): 
  
  I/DEBUG   (   86): code around pc:
  
  I/DEBUG   (   86): afd0c300 19d94f56 42ba690f 80a4f0c0 94001814 
  
  I/DEBUG   (   86): afd0c310 f08042a2 68d1809f 42916994 6895d00e 
  
  I/DEBUG   (   86): afd0c320 429668ee 8096f040 4296688e 8092f040 
  
  I/DEBUG   (   86): afd0c330 bf2442bd 608d60e9 e08bd21b b1116951 
  
  I/DEBUG   (   86): afd0c340 0514f102 6911e007 f102b191 e0020510 
  
  I/DEBUG   (   86): 
  
  I/DEBUG   (   86): code around lr:
  
  I/DEBUG   (   86): afd0c610 60f11008 f8c1608e 4e31c00c f10319a1 
  
  I/DEBUG   (   86): afd0c620 608a0608 e04b614d b1b2684a f7ff4628 
  
  I/DEBUG   (   86): afd0c630 e00ffe23 0f41f115 f04fbf88 d80c35ff 
  
  I/DEBUG   (   86): afd0c640 350b4927 0507f025 68431860 4628b12b 
  
  I/DEBUG   (   86): afd0c650 fc1cf7ff 28004606 4e21d132 689119a2 
  
  I/DEBUG   (   86): 
  
  I/DEBUG   (   86): stack:
  
  I/DEBUG   (   86):     be979408  000001e0  
  
  I/DEBUG   (   86):     be97940c  be979494  [stack]
  
  I/DEBUG   (   86):     be979410  be979438  [stack]
  
  I/DEBUG   (   86):     be979414  be979478  [stack]
  
  I/DEBUG   (   86):     be979418  0012f484  [heap]
  
  I/DEBUG   (   86):     be97941c  be979428  [stack]
  
  I/DEBUG   (   86):     be979420  00000000  
  
  I/DEBUG   (   86):     be979424  ab163cec  /system/lib/libskia.so
  
  I/DEBUG   (   86):     be979428  3f800000  
  
  I/DEBUG   (   86):     be97942c  80000000  /system/lib/libicudata.so
  
  I/DEBUG   (   86):     be979430  00000000  
  
  I/DEBUG   (   86):     be979434  80000000  /system/lib/libicudata.so
  
  I/DEBUG   (   86):     be979438  3f800000  
  
  I/DEBUG   (   86):     be97943c  00000000  
  
  I/DEBUG   (   86):     be979440  df002777  
  
  I/DEBUG   (   86):     be979444  e3a070ad  
  
  I/DEBUG   (   86): #00 be979448  0024fd18  [heap]
  
  I/DEBUG   (   86):     be97944c  afd4372c  /system/lib/libc.so
  
  I/DEBUG   (   86):     be979450  000000c5  
  
  I/DEBUG   (   86):     be979454  afd42328  /system/lib/libc.so
  
  I/DEBUG   (   86):     be979458  00000070  
  
  I/DEBUG   (   86):     be97945c  0000062c  
  
  I/DEBUG   (   86):     be979460  00000003  
  
  I/DEBUG   (   86):     be979464  afd0c633  /system/lib/libc.so
  
  I/DEBUG   (   86): #01 be979468  be9794c8  [stack]
  
  I/DEBUG   (   86):     be97946c  00000000  
  
  I/DEBUG   (   86):     be979470  002576bc  [heap]
  
  I/DEBUG   (   86):     be979474  ab163d2c  /system/lib/libskia.so
  
  I/DEBUG   (   86):     be979478  00000000  
  
  I/DEBUG   (   86):     be97947c  00000000  
  
  I/DEBUG   (   86):     be979480  44480000  /system/framework/framework-res.apk
  
  I/DEBUG   (   86):     be979484  00000068  
  
  I/DEBUG   (   86):     be979488  00000002  
  
  I/DEBUG   (   86):     be97948c  00000068  
  
  I/DEBUG   (   86):     be979490  00000003  
  
  I/DEBUG   (   86):     be979494  afd0cd41  /system/lib/libc.so
  
  E/Parcel  (  841): Reading a NULL string not supported here.

  Can any plz suggest me where I'm doing wrong.