예제 #1
0
  private static Bitmap createVideoThumbnailBitmap(
      String filePath, FileDescriptor fd, int targetWidth) {
    Bitmap bitmap = null;
    MediaMetadataRetriever retriever = new MediaMetadataRetriever();
    try {
      if (filePath != null) {
        retriever.setDataSource(filePath);
      } else {
        retriever.setDataSource(fd);
      }
      bitmap = retriever.getFrameAtTime(-1);
    } catch (IllegalArgumentException ex) {
      // Assume this is a corrupt video file
    } catch (RuntimeException ex) {
      // Assume this is a corrupt video file.
    } finally {
      try {
        retriever.release();
      } catch (RuntimeException ex) {
        // Ignore failures while cleaning up.
      }
    }
    if (bitmap == null) return null;

    // Scale down the bitmap if it is bigger than we need.
    int width = bitmap.getWidth();
    int height = bitmap.getHeight();
    if (width > targetWidth) {
      float scale = (float) targetWidth / width;
      int w = Math.round(scale * width);
      int h = Math.round(scale * height);
      bitmap = Bitmap.createScaledBitmap(bitmap, w, h, true);
    }
    return bitmap;
  }
예제 #2
0
 private Bitmap createVideoThumbnail(String url) {
   Bitmap bitmap = null;
   MediaMetadataRetriever retriever = new MediaMetadataRetriever();
   int kind = MediaStore.Video.Thumbnails.MINI_KIND;
   try {
     if (Build.VERSION.SDK_INT >= 14) {
       retriever.setDataSource(url, new HashMap<String, String>());
     } else {
       retriever.setDataSource(url);
     }
     bitmap = retriever.getFrameAtTime();
   } catch (IllegalArgumentException ex) {
     // Assume this is a corrupt video file
   } catch (RuntimeException ex) {
     // Assume this is a corrupt video file.
   } finally {
     try {
       retriever.release();
     } catch (RuntimeException ex) {
       // Ignore failures while cleaning up.
     }
   }
   if (kind == MediaStore.Images.Thumbnails.MICRO_KIND && bitmap != null) {
     bitmap =
         ThumbnailUtils.extractThumbnail(bitmap, 10, 10, ThumbnailUtils.OPTIONS_RECYCLE_INPUT);
   }
   return bitmap;
 }
 protected void updateMovieInfo() {
   mVideoWidth = mVideoHeight = mRotation = mBitrate = 0;
   mDuration = 0;
   mFrameRate = 0;
   String value = mMetadata.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH);
   if (!TextUtils.isEmpty(value)) {
     mVideoWidth = Integer.parseInt(value);
   }
   value = mMetadata.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT);
   if (!TextUtils.isEmpty(value)) {
     mVideoHeight = Integer.parseInt(value);
   }
   value = mMetadata.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION);
   if (!TextUtils.isEmpty(value)) {
     mRotation = Integer.parseInt(value);
   }
   value = mMetadata.extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE);
   if (!TextUtils.isEmpty(value)) {
     mBitrate = Integer.parseInt(value);
   }
   value = mMetadata.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
   if (!TextUtils.isEmpty(value)) {
     mDuration = Long.parseLong(value) * 1000;
   }
 }
예제 #4
0
 public Bitmap getFrameAtTime(long time) {
   if (retriever == null) {
     retriever = new MediaMetadataRetriever();
     retriever.setDataSource(filePath);
   }
   return retriever.getFrameAtTime(time * 1000, MediaMetadataRetriever.OPTION_CLOSEST);
 }
예제 #5
0
 public UFile(String path) {
   try {
     file = new File(path);
     this.path = file.getPath();
     this.name = file.getName();
     size = file.length();
     thumbNail = null;
     if (isMovie()) {
       MediaMetadataRetriever retriever = new MediaMetadataRetriever();
       retriever.setDataSource(path);
       String time = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
       movieLength = Long.parseLong(time);
       thumbNail =
           ThumbnailUtils.createVideoThumbnail(
               path, MediaStore.Video.Thumbnails.FULL_SCREEN_KIND);
     } else if (isImage()) {
       Bitmap temp = BitmapFactory.decodeFile(file.getPath());
       float scale = context.getResources().getDisplayMetrics().densityDpi / 160f;
       thumbNail =
           ThumbnailUtils.extractThumbnail(temp, (int) (50f * scale), (int) (50f * scale));
     } else if (file.isDirectory()) {
       thumbNail = BitmapFactory.decodeResource(null, R.mipmap.docu);
     }
   } catch (Exception e) {
     file = null;
   }
 }
예제 #6
0
 /**
  * 获取本地音乐缩略图的方法
  *
  * @param filePath
  * @return
  */
 @SuppressLint("NewApi")
 public static Bitmap getLocalMusicBitmap(String filePath) {
   Bitmap bitmap = null;
   MediaMetadataRetriever mmr = new MediaMetadataRetriever();
   mmr.setDataSource(filePath);
   bitmap = Bytes2Bimap(mmr.getEmbeddedPicture());
   return bitmap;
 }
 public static long getVideoDurationInMillis(String videoFile) {
   MediaMetadataRetriever retriever = new MediaMetadataRetriever();
   retriever.setDataSource(videoFile);
   String time = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
   long timeInmillisec = Long.parseLong(time);
   retriever.release();
   return timeInmillisec;
 }
  public static void setAlbumArt(ImageView imageview, String file, boolean compress) {

    String albumArtpath = allSongsList.getAlbumArt(file);

    if (albumArtpath != null) {
      File albumArtFile = new File(albumArtpath);
      Bitmap bm = null;
      InputStream iStream1 = null;
      InputStream iStream2 = null;

      try {

        iStream1 = new BufferedInputStream(new FileInputStream(albumArtFile));
        if (!compress) {
          bm = BitmapFactory.decodeStream(iStream1);
        } else {
          iStream2 = new BufferedInputStream(new FileInputStream(albumArtFile));
          bm = decodeFile2(iStream1, iStream2, 100, 100);
        }
        imageview.setImageBitmap(bm);

      } catch (FileNotFoundException e) {

        MediaMetadataRetriever md = new MediaMetadataRetriever();
        md.setDataSource(file);
        byte[] art = md.getEmbeddedPicture();
        if (art != null) {

          iStream1 = new ByteArrayInputStream(md.getEmbeddedPicture());

          if (!compress) {

            bm = BitmapFactory.decodeStream(iStream1);
          } else {
            iStream2 = new ByteArrayInputStream(md.getEmbeddedPicture());
            bm = decodeFile2(iStream1, iStream2, 100, 100);
          }
          imageview.setImageBitmap(bm);
        } else {
          imageview.setImageDrawable(
              imageview
                  .getContext()
                  .getResources()
                  .getDrawable(R.drawable.ic_expandplayer_placeholder));
        }
      }
    } else {
      imageview.setImageDrawable(
          imageview
              .getContext()
              .getResources()
              .getDrawable(R.drawable.ic_expandplayer_placeholder));
    }
  }
 public void setVideoPath(String path) {
   mediaMetadataRetriever = new MediaMetadataRetriever();
   try {
     mediaMetadataRetriever.setDataSource(path);
     String duration =
         mediaMetadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
     videoLength = Long.parseLong(duration);
   } catch (Exception e) {
     FileLog.e("tmessages", e);
   }
 }
 private int getDuration() {
   Movie movie = mItems.get(mCurrentItem);
   MediaMetadataRetriever mmr = new MediaMetadataRetriever();
   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
     mmr.setDataSource(movie.getVideoUrl(), new HashMap<String, String>());
   } else {
     mmr.setDataSource(movie.getVideoUrl());
   }
   String time = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
   long duration = Long.parseLong(time);
   return (int) duration;
 }
예제 #11
0
 // @TargetApi(11)
 private void calculateDuration(ContentValues map) throws IOException {
   if (Utils.isGingerBreadMROrLater()) {
     File videoFile = fileFromResourceMap(map);
     MediaMetadataRetriever mmr = new MediaMetadataRetriever();
     mmr.setDataSource(videoFile.toString());
     String duration = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
     if (!TextUtils.isEmpty(duration)) {
       map.put(Resources.DURATION, Integer.valueOf(duration));
     }
     mmr.release();
   }
 }
예제 #12
0
  public static Bitmap getBitmap(Context context, int id, boolean isImage) {
    String filename = getDataFilepathForMedia(context.getContentResolver(), id, isImage);

    /* ttt_installer:remove_line */ Log.d(GTG.TAG, "Loading bitmap for " + filename);

    if (filename == null) return null;

    if (isImage) return new BitmapDrawable(context.getResources(), filename).getBitmap();

    MediaMetadataRetriever mmr = new MediaMetadataRetriever();
    mmr.setDataSource(filename);
    return mmr.getFrameAtTime();
  }
  // Verify result code, result data, and the duration.
  private int verify(CameraActivity activity, Uri uri) throws Exception {
    assertTrue(activity.isFinishing());
    assertEquals(Activity.RESULT_OK, activity.getResultCode());

    // Verify the video file
    MediaMetadataRetriever retriever = new MediaMetadataRetriever();
    retriever.setDataSource(activity, uri);
    String duration = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
    assertNotNull(duration);
    int durationValue = Integer.parseInt(duration);
    Log.v(TAG, "Video duration is " + durationValue);
    assertTrue(durationValue > 0);
    return durationValue;
  }
예제 #14
0
  public static Bitmap getVideoFrame(Context context, Uri uri) {
    MediaMetadataRetriever retriever = new MediaMetadataRetriever();

    // Create a new Media Player
    MediaPlayer mp = MediaPlayer.create(context, uri);

    int millis = mp.getDuration();
    for (int i = 0; i < millis; i += 100) {
      Bitmap bitmap = retriever.getFrameAtTime(i, MediaMetadataRetriever.OPTION_CLOSEST_SYNC);
      retriever.release();
      return bitmap;
    }

    return null;
  }
 private final void handleStop() {
   if (DEBUG) Log.v(TAG, "handleStop:");
   synchronized (mVideoTask) {
     internal_stop_video();
     mVideoTrackIndex = -1;
   }
   if (mVideoMediaCodec != null) {
     mVideoMediaCodec.stop();
     mVideoMediaCodec.release();
     mVideoMediaCodec = null;
   }
   if (mVideoMediaExtractor != null) {
     mVideoMediaExtractor.release();
     mVideoMediaExtractor = null;
   }
   mVideoBufferInfo = null;
   mVideoInputBuffers = mVideoOutputBuffers = null;
   if (mMetadata != null) {
     mMetadata.release();
     mMetadata = null;
   }
   synchronized (mSync) {
     mVideoOutputDone = mVideoInputDone = true;
     mState = STATE_STOP;
   }
   mCallback.onFinished();
 }
 /**
  * @param sourceFile
  * @throws IOException
  */
 private final void handlePrepare(final String source_file) throws IOException {
   if (DEBUG) Log.v(TAG, "handlePrepare:");
   synchronized (mSync) {
     if (mState != STATE_STOP) {
       throw new RuntimeException("invalid state:" + mState);
     }
   }
   final File src = new File(source_file);
   if (TextUtils.isEmpty(source_file) || !src.canRead()) {
     throw new FileNotFoundException("Unable to read " + source_file);
   }
   mVideoTrackIndex = -1;
   mMetadata = new MediaMetadataRetriever();
   mMetadata.setDataSource(source_file);
   updateMovieInfo();
   // preparation for video playback
   mVideoTrackIndex = internal_prepare_video(source_file);
   if (mVideoTrackIndex < 0) {
     throw new RuntimeException("No video track found in " + source_file);
   }
   synchronized (mSync) {
     mState = STATE_PREPARED;
   }
   mCallback.onPrepared();
 }
예제 #17
0
  public void Destroy() {
    this.ClearList();
    this.DatabaseClose();

    if (metaDataReader != null) {
      metaDataReader.release();
    }
  }
  // two extra methods for async-loading of images
  public static Bitmap decodeAlbumArt(String file, boolean compress) {

    Bitmap toReturn = null;

    String albumArtpath = allSongsList.getAlbumArt(file);

    if (albumArtpath != null) {
      File albumArtFile = new File(albumArtpath);
      Bitmap bm = null;
      InputStream iStream1 = null;
      InputStream iStream2 = null;

      try {

        iStream1 = new BufferedInputStream(new FileInputStream(albumArtFile));
        if (!compress) {
          bm = BitmapFactory.decodeStream(iStream1);
        } else {
          iStream2 = new BufferedInputStream(new FileInputStream(albumArtFile));
          bm = decodeFile2(iStream1, iStream2, 100, 100);
        }

      } catch (FileNotFoundException e) {

        MediaMetadataRetriever md = new MediaMetadataRetriever();
        md.setDataSource(file);
        byte[] art = md.getEmbeddedPicture();
        if (art != null) {

          iStream1 = new ByteArrayInputStream(md.getEmbeddedPicture());

          if (!compress) {

            bm = BitmapFactory.decodeStream(iStream1);
          } else {
            iStream2 = new ByteArrayInputStream(md.getEmbeddedPicture());
            bm = decodeFile2(iStream1, iStream2, 100, 100);
          }
        }
      }
      toReturn = bm;
    }
    return toReturn;
  }
예제 #19
0
 private Bitmap getVideoPreview(File file, int size) {
   MediaMetadataRetriever metadataRetriever = new MediaMetadataRetriever();
   Bitmap frame;
   try {
     metadataRetriever.setDataSource(file.getAbsolutePath());
     frame = metadataRetriever.getFrameAtTime(0);
     metadataRetriever.release();
     frame = resize(frame, size);
   } catch (IllegalArgumentException | NullPointerException e) {
     frame = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888);
     frame.eraseColor(0xff000000);
   }
   Canvas canvas = new Canvas(frame);
   Bitmap play =
       BitmapFactory.decodeResource(mXmppConnectionService.getResources(), R.drawable.play_video);
   float x = (frame.getWidth() - play.getWidth()) / 2.0f;
   float y = (frame.getHeight() - play.getHeight()) / 2.0f;
   canvas.drawBitmap(play, x, y, null);
   return frame;
 }
예제 #20
0
 private Dimensions getVideoDimensions(File file) throws NotAVideoFile {
   MediaMetadataRetriever metadataRetriever = new MediaMetadataRetriever();
   try {
     metadataRetriever.setDataSource(file.getAbsolutePath());
   } catch (Exception e) {
     throw new NotAVideoFile();
   }
   String hasVideo =
       metadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_HAS_VIDEO);
   if (hasVideo == null) {
     throw new NotAVideoFile();
   }
   int rotation = extractRotationFromMediaRetriever(metadataRetriever);
   boolean rotated = rotation == 90 || rotation == 270;
   int height;
   try {
     String h =
         metadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT);
     height = Integer.parseInt(h);
   } catch (Exception e) {
     height = -1;
   }
   int width;
   try {
     String w = metadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH);
     width = Integer.parseInt(w);
   } catch (Exception e) {
     width = -1;
   }
   metadataRetriever.release();
   Log.d(Config.LOGTAG, "extracted video dims " + width + "x" + height);
   return rotated ? new Dimensions(width, height) : new Dimensions(height, width);
 }
예제 #21
0
  /**
   * Returns a (possibly empty) Cursor for given file path
   *
   * @param path The path to the file to be queried
   * @return A new Cursor object
   */
  public static Cursor getCursorForFileQuery(String path) {
    MatrixCursor matrixCursor = new MatrixCursor(Song.FILLED_PROJECTION);
    MediaMetadataRetriever data = new MediaMetadataRetriever();

    try {
      data.setDataSource(path);
    } catch (Exception e) {
      Log.w("VanillaMusic", "Failed to extract metadata from " + path);
    }

    String title = data.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE);
    String album = data.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUM);
    String artist = data.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST);
    String duration = data.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);

    if (duration != null) { // looks like we will be able to play this file
      // Vanilla requires each file to be identified by its unique id in the media database.
      // However: This file is not in the database, so we are going to roll our own
      // using the negative crc32 sum of the path value. While this is not perfect
      // (the same file may be accessed using various paths) it's the fastest method
      // and far good enough.
      CRC32 crc = new CRC32();
      crc.update(path.getBytes());
      Long songId =
          (Long) (2 + crc.getValue())
              * -1; // must at least be -2 (-1 defines Song-Object to be empty)

      // Build minimal fake-database entry for this file
      Object[] objData = new Object[] {songId, path, "", "", "", 0, 0, 0, 0};

      if (title != null) objData[2] = title;
      if (album != null) objData[3] = album;
      if (artist != null) objData[4] = artist;
      if (duration != null) objData[7] = Long.parseLong(duration, 10);

      matrixCursor.addRow(objData);
    }

    return matrixCursor;
  }
예제 #22
0
  private void initMediaDuration(Uri uri) throws MmsException {
    if (uri == null) {
      throw new IllegalArgumentException("Uri may not be null.");
    }

    MediaMetadataRetriever retriever = new MediaMetadataRetriever();
    int duration = 0;
    try {
      retriever.setDataSource(mContext, uri);
      String dur = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
      if (dur != null) {
        duration = Integer.parseInt(dur);
      }
      mDuration = duration;
      Xlog.i(TAG, "Got audio duration:" + duration);
    } catch (Exception ex) {
      Xlog.e(TAG, "MediaMetadataRetriever failed to get duration for " + uri.getPath(), ex);
      throw new MmsException(ex);
    } finally {
      retriever.release();
    }
  }
    @Override
    public Bitmap getBitmap(int position) {
      MusicInfo musicInfo = (MusicInfo) getItem(position);

      MediaMetadataRetriever retriever = new MediaMetadataRetriever();
      retriever.setDataSource(mContext, musicInfo.getUri());

      byte[] albumArt = retriever.getEmbeddedPicture();

      BitmapFactory.Options options = new BitmapFactory.Options();
      options.inSampleSize = 4; // 2의 배수

      Bitmap bitmap;
      if (null != albumArt) {
        bitmap = BitmapFactory.decodeByteArray(albumArt, 0, albumArt.length, options);
      } else {
        bitmap = BitmapFactory.decodeResource(mContext.getResources(), R.mipmap.ic_no_image);
      }

      // id 로부터 bitmap 생성
      return bitmap;
    }
  public void sendVideo(Peer peer, String fullFilePath, String fileName) {
    try {
      MediaMetadataRetriever retriever = new MediaMetadataRetriever();
      retriever.setDataSource(fullFilePath);
      int duration =
          (int)
              (Long.parseLong(
                      retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION))
                  / 1000L);
      Bitmap img = retriever.getFrameAtTime(0);
      int width = img.getWidth();
      int height = img.getHeight();
      Bitmap smallThumb = ImageHelper.scaleFit(img, 90, 90);
      byte[] smallThumbData = ImageHelper.save(smallThumb);

      FastThumb thumb =
          new FastThumb(smallThumb.getWidth(), smallThumb.getHeight(), smallThumbData);

      sendVideo(peer, fileName, width, height, duration, thumb, fullFilePath);
    } catch (Throwable e) {
      e.printStackTrace();
    }
  }
예제 #25
0
 private int extractRotationFromMediaRetriever(MediaMetadataRetriever metadataRetriever) {
   int rotation;
   if (Build.VERSION.SDK_INT >= 17) {
     String r =
         metadataRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION);
     try {
       rotation = Integer.parseInt(r);
     } catch (Exception e) {
       rotation = 0;
     }
   } else {
     rotation = 0;
   }
   return rotation;
 }
예제 #26
0
  public void UpdateList() {
    this.ClearList();

    // TODO EXITST BUT MAYBE BLANK!?!

    if (!syncDB.Exists() || syncDB.IsEmpty()) {
      try {
        metaDataReader = new MediaMetadataRetriever();
        CheckDir(preferences.GetMediaPath());
        metaDataReader.release();
      } catch (NullPointerException e) {
        Log.v(preferences.GetTag(), e.getMessage());
      }

      syncDB = new Database(mainContext);
      this.DatabasePush();
    } else {
      this.DatabasePull();
    }
  }
예제 #27
0
 private void addSongToList(File file) {
   if (file.getName().endsWith(".mp3")) {
     DatabaseHandler db = new DatabaseHandler(Setting.this);
     String songName = file.getName().substring(0, (file.getName().length() - 4));
     String songPath = file.getPath();
     MediaMetadataRetriever media = new MediaMetadataRetriever();
     media.setDataSource(songPath);
     byte[] data = media.getEmbeddedPicture();
     String songArtist = media.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST);
     String songAlbum = media.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUM);
     media.release();
     db.addSongData(new SongData(songName, songPath, songArtist, songAlbum, data, 0));
     db.close();
   }
 }
 public void destroy() {
   synchronized (sync) {
     try {
       if (mediaMetadataRetriever != null) {
         mediaMetadataRetriever.release();
         mediaMetadataRetriever = null;
       }
     } catch (Exception e) {
       FileLog.e("tmessages", e);
     }
   }
   for (Bitmap bitmap : frames) {
     if (bitmap != null) {
       bitmap.recycle();
     }
   }
   frames.clear();
   if (currentTask != null) {
     currentTask.cancel(true);
     currentTask = null;
   }
 }
예제 #29
0
  public AlbumMetaData mediaMetaData(String file_path) {
    AlbumMetaData albumMetaData = new AlbumMetaData();
    try {
      if (mmr == null) {
        mmr = new MediaMetadataRetriever();
      }
      mmr.setDataSource(file_path);

      albumMetaData.file_path = file_path;
      albumMetaData.title = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE);
      albumMetaData.album_artist =
          mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUMARTIST);
      albumMetaData.artist = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST);
      albumMetaData.author = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_AUTHOR);
      albumMetaData.genre = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_AUTHOR);
      albumMetaData.duration = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
      // albumMetaData.album_art = mmr.getEmbeddedPicture();
    } catch (Exception ex) {
      Log.e("Error: ", "Unable to get meta data");
    }
    if (albumMetaData.file_path == null || albumMetaData.file_path.isEmpty())
      albumMetaData.file_path = "";
    if (albumMetaData.album_artist == null || albumMetaData.album_artist.isEmpty())
      albumMetaData.album_artist = "Unknown Album Artist";
    if (albumMetaData.title == null || albumMetaData.title.isEmpty())
      albumMetaData.title = "Unknown Title";
    if (albumMetaData.artist == null || albumMetaData.artist.isEmpty())
      albumMetaData.artist = "Unknown Artist";
    if (albumMetaData.author == null || albumMetaData.author.isEmpty())
      albumMetaData.author = "Unknown Author";
    if (albumMetaData.genre == null || albumMetaData.genre.isEmpty())
      albumMetaData.genre = "Unknown Genre";
    if (albumMetaData.duration == null || albumMetaData.duration.isEmpty())
      albumMetaData.duration = "-:-";
    mmr.release();
    return albumMetaData;
  }
예제 #30
0
  private boolean RetrieverFile(String path, int nType) {
    nVideoW = 0;
    nVideoH = 0;
    // 取得影片寬高
    MediaMetadataRetriever metaRetriever = new MediaMetadataRetriever();
    // --20150327-fix crash bug
    try {
      metaRetriever.setDataSource(path);
    } catch (Exception e) {
      e.printStackTrace();
      metaRetriever.release();
      Log.v(TAG, "PATH=" + path);
      Log.e(TAG, "MediaMetadataRetriever setDataSource error");
      return false;
    } // !--20150327-fix crash bug

    if (nType == 1) {
      String temp = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH);
      if (temp != null) {
        try {
          nVideoW = Integer.parseInt(temp);
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
      temp = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT);
      if (temp != null) {
        try {
          nVideoH = Integer.parseInt(temp);
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    }
    metaRetriever.release();
    return true;
  }