android - Mecanismo para que las aplicaciones muestren su contenido de imagen en 4k nativo

android-ndk android-videoview

Question

Según tengo entendido, actualmente el contenido de video UHD se transmite en 4k TV, principalmente utilizando el HEVC codec .

Quiero entender cómo las aplicaciones que tienen contenido de imagen UHD pueden mostrar su contenido de imagen en 4K nativo.

Lo que estoy buscando exactamente es renderizar imágenes jpeg de 4k(3840*2060) . Mi pantalla admite la representación de 4k y el SOC puede incluso generar 4k. Estoy buscando modificaciones en el marco, para que todas las aplicaciones que tienen imágenes de 4k puedan renderizarlas en mi dispositivo sin tener que reducir la escala.

En realidad, estoy tratando de crear un conjunto de API que otros puedan usar. Pero mi principal confusión es: para la imagen jpeg creo una superficie de 4k, pero también hay otras superficies (botones, etc.). Están representados por un deflector de superficie que rinde a 1280*720 .

Ahora, ¿cuál es la mejor manera de componer mi superficie 4k con estas otras superficies? ¿Dónde debo ampliar estas superficies y dónde componerlas todas?

Answer 1

Una cosa importante a tener en cuenta es qué tipo de desarrollo tiene en mente. Si simplemente desea poner un flujo de video que se muestre dentro de su aplicación, debe utilizar la interfaz de usuario para la actividad principal que consistirá simplemente en una instancia de la clase VideoView. La clase VideoView tiene una amplia gama de métodos a los que se puede recurrir para administrar la reproducción de video.

Configure el VideoView con la ruta del video a reproducir y luego inicie la reproducción. Luego seleccione el archivo VideoPlayerActivity.java y modifique el método OnCreate () como se describe en la siguiente lista:

package com.example.videoplayer;
import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
import android.widget.VideoView;
public class VideoPlayerActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_video_player);
final VideoView videoView =
(VideoView) findViewById(R.id.videoView1);
videoView.setVideoPath(
"http://www.ebookfrenzy.com/android_book/movie.mp4");
videoView.start();
}
.
.
.
}

Esencialmente, lo que tienes es el SDK de Android para la interfaz de usuario de la aplicación, lo que significa que puedes usar diferentes opciones para procesar la streaming video debajo de la capa de la interfaz de usuario.

La migración de su aplicación ya existente de una tableta o dispositivo móvil a un televisor inteligente también es algo que se puede lograr con bastante facilidad. Algunas pocas cosas tendrán que ajustarse, por ejemplo, la pantalla táctil generalmente para smart TV puede no ser una opción.

En su lugar, debe considerar onkeyDown como un método más confiable para ingresar interacción para su aplicación:

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
switch (keyCode) {
case KeyEvent.KEYCODE_MEDIA_PLAY:{
if (!mPlaying) {
startSlideShow();
}
mPlaying = true;
break;
}
case KeyEvent.KEYCODE_MEDIA_PAUSE:{
mPlaying = false;
showStatusToast(R.string.slideshow_paused);
}
}
return super.onKeyDown(keyCode, event);
}

Como parte de la API de Google Smart TV de Android, también puede realizar los ajustes necesarios para resoluciones de pantalla más grandes:

 // Get the source image''s dimensions
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true; // this does not download the actual image, just downloads headers.
BitmapFactory.decodeFile(IMAGE_FILE_URL, options);
int srcWidth = options.outWidth; // actual width of the image.
int srcHeight = options.outHeight; // actual height of the image.
// Only scale if the source is big enough. This code is just trying to fit a image into a certain width.
if(desiredWidth > srcWidth)
desiredWidth = srcWidth;
// Calculate the correct inSampleSize/scale value. This helps reduce memory use. It should be a power of 2.
int inSampleSize = 1;
while(srcWidth / 2 > desiredWidth){
srcWidth /= 2;
srcHeight /= 2;
inSampleSize *= 2;
}
float desiredScale = (float) desiredWidth / srcWidth;
// Decode with inSampleSize
options.inJustDecodeBounds = false; // now download the actual image.
options.inDither = false;
options.inSampleSize = inSampleSize;
options.inScaled = false;
options.inPreferredConfig = Bitmap.Config.ARGB_8888; // ensures the image stays as a 32-bit ARGB_8888 image.
// This preserves image quality.
Bitmap sampledSrcBitmap = BitmapFactory.decodeFile(IMAGE_FILE_URL, options);
// Resize
Matrix matrix = new Matrix();
matrix.postScale(desiredScale, desiredScale);
Bitmap scaledBitmap = Bitmap.createBitmap(sampledSrcBitmap, 0, 0,
sampledSrcBitmap.getWidth(), sampledSrcBitmap.getHeight(), matrix, true);
sampledSrcBitmap = null;
// Save
FileOutputStream out = new FileOutputStream(LOCAL_PATH_TO_STORE_IMAGE);
scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 100, out);
scaledBitmap = null;

También puede convertir fácilmente su televisor LCD en un televisor inteligente y comenzar a jugar y probar cómo se comportaría su aplicación para Google TV. Para eso solo necesitas poner tus manos en el kit adaptador .

De hecho, Lenovo está lanzando un monitor 4K de 28 pulgadas (el ThinkVision 28) que también funciona con Android , lo que le permite ejecutar todas las aplicaciones de transmisión multimedia habituales, y Kogan está haciendo lo mismo.

Al piratear un poco más en juegos con gadgets, incluso puede bloquear su teléfono móvil con MHL HDMI en un televisor o usarlo como computer .

Por lo tanto, Android que trabaja con engadget.com/2014/03/03/mhl-3-0-4k-sony-xperia-z2 salida de engadget.com/2014/03/03/mhl-3-0-4k-sony-xperia-z2 sea ​​una realidad que los buenos desarrolladores ya pueden hacer sus aplicaciones con la resolución y el ajuste de entrada necesarios para el dispositivo en uso.

Si su principal preocupación es aumentar el rendimiento y optimizar la transmisión de video, puede considerar las siguientes opciones:

• NDK: decide tomar alguna biblioteca o implementar su propio programa que realmente está hecho en C ++ para optimizar la transmisión de video .
• RenderScript: utiliza la sintaxis C99 con nuevas API que se compilan en última instancia en código nativo . Si bien esta sintaxis es bien conocida, hay una curva de aprendizaje para usar este sistema porque las API no lo son.
• OpenCL: está diseñado para la aceleración de gráficos y proporciona muchas herramientas para renderizado 3D y alto flujo de video.

De hecho, el código en OpenCL se parece a C / C ++:

 for (int yy=-filterWidth; yy<=filterWidth; ++yy)
{
for (int xx=-filterWidth; xx<=filterWidth; ++xx)
{
int thisIndex = (y + yy) * width + (x + xx);
float4 currentPixel = oneover255 *convert_float4(srcBuffer[thisIndex]);
float domainDistance = fast_distance((float)(xx), (float)(yy));
float domainWeight = exp(-0.5f * pow((domainDistance/sigmaDomain),2.0f));
float rangeDistance = fast_distance(currentPixel.xyz, centerPixel.xyz);
float rangeWeight = exp(-0.5f * pow((rangeDistance/sigmaRange),2.0f));
float totalWeight = domainWeight * rangeWeight ;
normalizeCoeff += totalWeight;
sum4 += totalWeight * currentPixel;
}
}

En términos de capacidades de microprocesadores ARM, vale la pena mencionar el ARM Sigma Designs SMP8756 para Android Set-top-boxes, destinado a abordar todas las capacidades de codificación de video de alta eficiencia ( HEVC ).

• Filtrado bilineal

Para cambiar el tamaño de su imagen / video, lo que necesita es aplicar un filtro bilineal . La interpolación bilineal es el proceso de usar cada uno de los campos intermedios en un cuadro de video entrelazado para generar una imagen objetivo de tamaño completo. Se utilizan todas las líneas pares o impares en el campo. Luego se realizan interpolaciones entre las líneas y entre los píxeles adyacentes para generar un marco completo no entrelazado para la salida de exploración progresiva.

Para implementar su imagen ajustada correctamente para los tamaños que necesita, hay un montón de buenos algoritmos que se pueden usar para ese propósito, como algunas de las características de OpenCL para el escalado de imágenes , y también para C ++ nativo, otras opciones también están available .