?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
add_savefile: remove callback parameter
[vlc/asuraparaju-public.git] / modules / codec / omxil / utils.c
blobdf1c0769d80bfd6494c95e53d952cc1142a40541
1 /*****************************************************************************
2 * utils.c: helper functions
3 *****************************************************************************
4 * Copyright (C) 2010 the VideoLAN team
5 * $Id$
6 *
7 * Authors: Gildas Bazin <gbazin@videolan.org>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
23
24 /*****************************************************************************
25 * Preamble
26 *****************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #if defined(HAVE_DL_DLOPEN)
32 # include <dlfcn.h>
33 #endif
34
35 #include <vlc_common.h>
36 #include <vlc_plugin.h>
37 #include <vlc_codec.h>
38 #include <vlc_block_helper.h>
39 #include <vlc_cpu.h>
40
41 #include "omxil.h"
42
43 /*****************************************************************************
44 * Events utility functions
45 *****************************************************************************/
46 OMX_ERRORTYPE PostOmxEvent(decoder_t *p_dec, OMX_EVENTTYPE event,
47 OMX_U32 data_1, OMX_U32 data_2, OMX_PTR event_data)
48 {
49 decoder_sys_t *p_sys = p_dec->p_sys;
50 OmxEvent *p_event;
51
52 p_event = malloc(sizeof(OmxEvent));
53 if(!p_event) return OMX_ErrorInsufficientResources;
54
55 p_event->event = event;
56 p_event->data_1 = data_1;
57 p_event->data_2 = data_2;
58 p_event->event_data = event_data;
59 p_event->next = 0;
60
61 vlc_mutex_lock(&p_sys->mutex);
62 *p_sys->pp_last_event = p_event;
63 p_sys->pp_last_event = &p_event->next;
64 vlc_cond_signal(&p_sys->cond);
65 vlc_mutex_unlock(&p_sys->mutex);
66 return OMX_ErrorNone;
67 }
68
69 OMX_ERRORTYPE WaitForOmxEvent(decoder_t *p_dec, OMX_EVENTTYPE *event,
70 OMX_U32 *data_1, OMX_U32 *data_2, OMX_PTR *event_data)
71 {
72 decoder_sys_t *p_sys = p_dec->p_sys;
73 OmxEvent *p_event;
74
75 vlc_mutex_lock(&p_sys->mutex);
76
77 if(!p_sys->p_events)
78 vlc_cond_timedwait(&p_sys->cond, &p_sys->mutex, mdate()+CLOCK_FREQ);
79
80 p_event = p_sys->p_events;
81 if(p_event)
82 {
83 p_sys->p_events = p_event->next;
84 if(!p_sys->p_events) p_sys->pp_last_event = &p_sys->p_events;
85 }
86
87 vlc_mutex_unlock(&p_sys->mutex);
88
89 if(p_event)
90 {
91 if(event) *event = p_event->event;
92 if(data_1) *data_1 = p_event->data_1;
93 if(data_2) *data_2 = p_event->data_2;
94 if(event_data) *event_data = p_event->event_data;
95 free(p_event);
96 return OMX_ErrorNone;
97 }
98
99 return OMX_ErrorTimeout;
100 }
101
102 OMX_ERRORTYPE WaitForSpecificOmxEvent(decoder_t *p_dec,
103 OMX_EVENTTYPE specific_event, OMX_U32 *data_1, OMX_U32 *data_2,
104 OMX_PTR *event_data)
105 {
106 OMX_ERRORTYPE status;
107 OMX_EVENTTYPE event;
108 mtime_t before = mdate();
109
110 while(1)
111 {
112 status = WaitForOmxEvent(p_dec, &event, data_1, data_2, event_data);
113 if(status != OMX_ErrorNone) return status;
114
115 if(event == specific_event) break;
116 if(mdate() - before > CLOCK_FREQ) return OMX_ErrorTimeout;
117 }
118
119 return OMX_ErrorNone;
120 }
121
122 /*****************************************************************************
123 * Picture utility functions
124 *****************************************************************************/
125 void CopyOmxPicture( decoder_t *p_dec, picture_t *p_pic,
126 OMX_BUFFERHEADERTYPE *p_header )
127 {
128 decoder_sys_t *p_sys = p_dec->p_sys;
129 int i_src_stride, i_dst_stride;
130 int i_plane, i_width, i_line;
131 uint8_t *p_dst, *p_src;
132
133 i_src_stride = p_sys->out.i_frame_stride;
134 p_src = p_header->pBuffer + p_header->nOffset;
135
136 for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
137 {
138 if(i_plane == 1) i_src_stride /= p_sys->out.i_frame_stride_chroma_div;
139 p_dst = p_pic->p[i_plane].p_pixels;
140 i_dst_stride = p_pic->p[i_plane].i_pitch;
141 i_width = p_pic->p[i_plane].i_visible_pitch;
142
143 for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines; i_line++ )
144 {
145 vlc_memcpy( p_dst, p_src, i_width );
146 p_src += i_src_stride;
147 p_dst += i_dst_stride;
148 }
149 }
150 }
151
152 void CopyVlcPicture( decoder_t *p_dec, OMX_BUFFERHEADERTYPE *p_header,
153 picture_t *p_pic)
154 {
155 decoder_sys_t *p_sys = p_dec->p_sys;
156 int i_src_stride, i_dst_stride;
157 int i_plane, i_width, i_line;
158 uint8_t *p_dst, *p_src;
159
160 i_dst_stride = p_sys->out.i_frame_stride;
161 p_dst = p_header->pBuffer + p_header->nOffset;
162
163 for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
164 {
165 if(i_plane == 1) i_dst_stride /= p_sys->in.i_frame_stride_chroma_div;
166 p_src = p_pic->p[i_plane].p_pixels;
167 i_src_stride = p_pic->p[i_plane].i_pitch;
168 i_width = p_pic->p[i_plane].i_visible_pitch;
169
170 for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines; i_line++ )
171 {
172 vlc_memcpy( p_dst, p_src, i_width );
173 p_src += i_src_stride;
174 p_dst += i_dst_stride;
175 }
176 }
177 }
178
179 /*****************************************************************************
180 * Logging utility functions
181 *****************************************************************************/
182 const char *StateToString(OMX_STATETYPE state)
183 {
184 static const char *psz_names[] = {
185 "OMX_StateInvalid", "OMX_StateLoaded", "OMX_StateIdle",
186 "OMX_StateExecuting", "OMX_StatePause", "OMX_StateWaitForResources",
187 "OMX_State unknown"
188 };
189
190 if((unsigned int)state > sizeof(psz_names)/sizeof(char*)-1)
191 state = (OMX_STATETYPE)(sizeof(psz_names)/sizeof(char*)-1);
192 return psz_names[state];
193 }
194
195 const char *CommandToString(OMX_COMMANDTYPE command)
196 {
197 static const char *psz_names[] = {
198 "OMX_CommandStateSet", "OMX_CommandFlush", "OMX_CommandPortDisable",
199 "OMX_CommandPortEnable", "OMX_CommandMarkBuffer",
200 "OMX_Command unknown"
201 };
202
203 if((unsigned int)command > sizeof(psz_names)/sizeof(char*)-1)
204 command = (OMX_COMMANDTYPE)(sizeof(psz_names)/sizeof(char*)-1);
205 return psz_names[command];
206 }
207
208 const char *EventToString(OMX_EVENTTYPE event)
209 {
210 static const char *psz_names[] = {
211 "OMX_EventCmdComplete", "OMX_EventError", "OMX_EventMark",
212 "OMX_EventPortSettingsChanged", "OMX_EventBufferFlag",
213 "OMX_EventResourcesAcquired", "OMX_EventComponentResumed",
214 "OMX_EventDynamicResourcesAvailable", "OMX_EventPortFormatDetected",
215 "OMX_Event unknown"
216 };
217
218 if((unsigned int)event > sizeof(psz_names)/sizeof(char*)-1)
219 event = (OMX_EVENTTYPE)(sizeof(psz_names)/sizeof(char*)-1);
220 return psz_names[event];
221 }
222
223 const char *ErrorToString(OMX_ERRORTYPE error)
224 {
225 static const char *psz_names[] = {
226 "OMX_ErrorInsufficientResources", "OMX_ErrorUndefined",
227 "OMX_ErrorInvalidComponentName", "OMX_ErrorComponentNotFound",
228 "OMX_ErrorInvalidComponent", "OMX_ErrorBadParameter",
229 "OMX_ErrorNotImplemented", "OMX_ErrorUnderflow",
230 "OMX_ErrorOverflow", "OMX_ErrorHardware", "OMX_ErrorInvalidState",
231 "OMX_ErrorStreamCorrupt", "OMX_ErrorPortsNotCompatible",
232 "OMX_ErrorResourcesLost", "OMX_ErrorNoMore", "OMX_ErrorVersionMismatch",
233 "OMX_ErrorNotReady", "OMX_ErrorTimeout", "OMX_ErrorSameState",
234 "OMX_ErrorResourcesPreempted", "OMX_ErrorPortUnresponsiveDuringAllocation",
235 "OMX_ErrorPortUnresponsiveDuringDeallocation",
236 "OMX_ErrorPortUnresponsiveDuringStop", "OMX_ErrorIncorrectStateTransition",
237 "OMX_ErrorIncorrectStateOperation", "OMX_ErrorUnsupportedSetting",
238 "OMX_ErrorUnsupportedIndex", "OMX_ErrorBadPortIndex",
239 "OMX_ErrorPortUnpopulated", "OMX_ErrorComponentSuspended",
240 "OMX_ErrorDynamicResourcesUnavailable", "OMX_ErrorMbErrorsInFrame",
241 "OMX_ErrorFormatNotDetected", "OMX_ErrorContentPipeOpenFailed",
242 "OMX_ErrorContentPipeCreationFailed", "OMX_ErrorSeperateTablesUsed",
243 "OMX_ErrorTunnelingUnsupported",
244 "OMX_Error unkown"
245 };
246
247 if(error == OMX_ErrorNone) return "OMX_ErrorNone";
248
249 error -= OMX_ErrorInsufficientResources;
250
251 if((unsigned int)error > sizeof(psz_names)/sizeof(char*)-1)
252 error = (OMX_STATETYPE)(sizeof(psz_names)/sizeof(char*)-1);
253 return psz_names[error];
254 }
255
256 /*****************************************************************************
257 * fourcc -> omx id mapping
258 *****************************************************************************/
259 static const struct
260 {
261 vlc_fourcc_t i_fourcc;
262 OMX_VIDEO_CODINGTYPE i_codec;
263 const char *psz_role;
264
265 } video_format_table[] =
266 {
267 { VLC_CODEC_MPGV, OMX_VIDEO_CodingMPEG2, "video_decoder.mpeg2" },
268 { VLC_CODEC_MP4V, OMX_VIDEO_CodingMPEG4, "video_decoder.mpeg4" },
269 { VLC_CODEC_H264, OMX_VIDEO_CodingAVC, "video_decoder.avc" },
270 { VLC_CODEC_H263, OMX_VIDEO_CodingH263, "video_decoder.h263" },
271 { VLC_CODEC_WMV1, OMX_VIDEO_CodingWMV, "video_decoder.wmv" },
272 { VLC_CODEC_WMV2, OMX_VIDEO_CodingWMV, "video_decoder.wmv" },
273 { VLC_CODEC_WMV3, OMX_VIDEO_CodingWMV, "video_decoder.wmv" },
274 { VLC_CODEC_MJPG, OMX_VIDEO_CodingMJPEG, "video_decoder.jpeg" },
275 { VLC_CODEC_RV10, OMX_VIDEO_CodingRV, "video_decoder.rv" },
276 { VLC_CODEC_RV20, OMX_VIDEO_CodingRV, "video_decoder.rv" },
277 { VLC_CODEC_RV30, OMX_VIDEO_CodingRV, "video_decoder.rv" },
278 { VLC_CODEC_RV40, OMX_VIDEO_CodingRV, "video_decoder.rv" },
279 { 0, 0, 0 }
280 };
281
282 static const struct
283 {
284 vlc_fourcc_t i_fourcc;
285 OMX_AUDIO_CODINGTYPE i_codec;
286 const char *psz_role;
287
288 } audio_format_table[] =
289 {
290 { VLC_CODEC_AMR_NB, OMX_AUDIO_CodingAMR, "audio_decoder.amr" },
291 { VLC_CODEC_AMR_WB, OMX_AUDIO_CodingAMR, "audio_decoder.amr" },
292 { VLC_CODEC_MP4A, OMX_AUDIO_CodingAAC, "audio_decoder.aac" },
293 { VLC_CODEC_S16N, OMX_AUDIO_CodingPCM, "audio_decoder.pcm" },
294 { 0, 0, 0 }
295 };
296
297 static const struct
298 {
299 vlc_fourcc_t i_fourcc;
300 OMX_VIDEO_CODINGTYPE i_codec;
301 const char *psz_role;
302
303 } video_enc_format_table[] =
304 {
305 { VLC_CODEC_MPGV, OMX_VIDEO_CodingMPEG2, "video_encoder.mpeg2" },
306 { VLC_CODEC_MP4V, OMX_VIDEO_CodingMPEG4, "video_encoder.mpeg4" },
307 { VLC_CODEC_H264, OMX_VIDEO_CodingAVC, "video_encoder.avc" },
308 { VLC_CODEC_H263, OMX_VIDEO_CodingH263, "video_encoder.h263" },
309 { VLC_CODEC_WMV1, OMX_VIDEO_CodingWMV, "video_encoder.wmv" },
310 { VLC_CODEC_WMV2, OMX_VIDEO_CodingWMV, "video_encoder.wmv" },
311 { VLC_CODEC_WMV3, OMX_VIDEO_CodingWMV, "video_encoder.wmv" },
312 { VLC_CODEC_MJPG, OMX_VIDEO_CodingMJPEG, "video_encoder.jpeg" },
313 { VLC_CODEC_RV10, OMX_VIDEO_CodingRV, "video_encoder.rv" },
314 { VLC_CODEC_RV20, OMX_VIDEO_CodingRV, "video_encoder.rv" },
315 { VLC_CODEC_RV30, OMX_VIDEO_CodingRV, "video_encoder.rv" },
316 { VLC_CODEC_RV40, OMX_VIDEO_CodingRV, "video_encoder.rv" },
317 { 0, 0, 0 }
318 };
319
320 static const struct
321 {
322 vlc_fourcc_t i_fourcc;
323 OMX_AUDIO_CODINGTYPE i_codec;
324 const char *psz_role;
325
326 } audio_enc_format_table[] =
327 {
328 { VLC_CODEC_AMR_NB, OMX_AUDIO_CodingAMR, "audio_encoder.amr" },
329 { VLC_CODEC_AMR_WB, OMX_AUDIO_CodingAMR, "audio_encoder.amr" },
330 { VLC_CODEC_MP4A, OMX_AUDIO_CodingAAC, "audio_encoder.aac" },
331 { VLC_CODEC_S16N, OMX_AUDIO_CodingPCM, "audio_encoder.pcm" },
332 { 0, 0, 0 }
333 };
334
335 static const struct
336 {
337 vlc_fourcc_t i_fourcc;
338 OMX_COLOR_FORMATTYPE i_codec;
339 unsigned int i_size_mul;
340 unsigned int i_line_mul;
341 unsigned int i_line_chroma_div;
342
343 } chroma_format_table[] =
344 {
345 { VLC_CODEC_I420, OMX_COLOR_FormatYUV420Planar, 3, 1, 2 },
346 { VLC_CODEC_I420, OMX_COLOR_FormatYUV420PackedPlanar, 3, 1, 2 },
347 { VLC_CODEC_YUYV, OMX_COLOR_FormatYCbYCr, 4, 2, 0 },
348 { VLC_CODEC_YVYU, OMX_COLOR_FormatYCrYCb, 4, 2, 0 },
349 { VLC_CODEC_UYVY, OMX_COLOR_FormatCbYCrY, 4, 2, 0 },
350 { VLC_CODEC_VYUY, OMX_COLOR_FormatCrYCbY, 4, 2, 0 },
351 { 0, 0, 0, 0, 0 }
352 };
353
354 int GetOmxVideoFormat( vlc_fourcc_t i_fourcc,
355 OMX_VIDEO_CODINGTYPE *pi_omx_codec,
356 const char **ppsz_name )
357 {
358 unsigned int i;
359
360 i_fourcc = vlc_fourcc_GetCodec( VIDEO_ES, i_fourcc );
361
362 for( i = 0; video_format_table[i].i_codec != 0; i++ )
363 if( video_format_table[i].i_fourcc == i_fourcc ) break;
364
365 if( pi_omx_codec ) *pi_omx_codec = video_format_table[i].i_codec;
366 if( ppsz_name ) *ppsz_name = vlc_fourcc_GetDescription( VIDEO_ES, i_fourcc );
367 return !!video_format_table[i].i_codec;
368 }
369
370 int GetVlcVideoFormat( OMX_VIDEO_CODINGTYPE i_omx_codec,
371 vlc_fourcc_t *pi_fourcc, const char **ppsz_name )
372 {
373 unsigned int i;
374
375 for( i = 0; video_format_table[i].i_codec != 0; i++ )
376 if( video_format_table[i].i_codec == i_omx_codec ) break;
377
378 if( pi_fourcc ) *pi_fourcc = video_format_table[i].i_fourcc;
379 if( ppsz_name ) *ppsz_name = vlc_fourcc_GetDescription( VIDEO_ES,
380 video_format_table[i].i_fourcc );
381 return !!video_format_table[i].i_fourcc;
382 }
383
384 static const char *GetOmxVideoRole( vlc_fourcc_t i_fourcc )
385 {
386 unsigned int i;
387
388 i_fourcc = vlc_fourcc_GetCodec( VIDEO_ES, i_fourcc );
389
390 for( i = 0; video_format_table[i].i_codec != 0; i++ )
391 if( video_format_table[i].i_fourcc == i_fourcc ) break;
392
393 return video_format_table[i].psz_role;
394 }
395
396 static const char *GetOmxVideoEncRole( vlc_fourcc_t i_fourcc )
397 {
398 unsigned int i;
399
400 i_fourcc = vlc_fourcc_GetCodec( VIDEO_ES, i_fourcc );
401
402 for( i = 0; video_enc_format_table[i].i_codec != 0; i++ )
403 if( video_enc_format_table[i].i_fourcc == i_fourcc ) break;
404
405 return video_enc_format_table[i].psz_role;
406 }
407
408 int GetOmxAudioFormat( vlc_fourcc_t i_fourcc,
409 OMX_AUDIO_CODINGTYPE *pi_omx_codec,
410 const char **ppsz_name )
411 {
412 unsigned int i;
413
414 i_fourcc = vlc_fourcc_GetCodec( AUDIO_ES, i_fourcc );
415
416 for( i = 0; audio_format_table[i].i_codec != 0; i++ )
417 if( audio_format_table[i].i_fourcc == i_fourcc ) break;
418
419 if( pi_omx_codec ) *pi_omx_codec = audio_format_table[i].i_codec;
420 if( ppsz_name ) *ppsz_name = vlc_fourcc_GetDescription( AUDIO_ES, i_fourcc );
421 return !!audio_format_table[i].i_codec;
422 }
423
424 int GetVlcAudioFormat( OMX_AUDIO_CODINGTYPE i_omx_codec,
425 vlc_fourcc_t *pi_fourcc, const char **ppsz_name )
426 {
427 unsigned int i;
428
429 for( i = 0; audio_format_table[i].i_codec != 0; i++ )
430 if( audio_format_table[i].i_codec == i_omx_codec ) break;
431
432 if( pi_fourcc ) *pi_fourcc = audio_format_table[i].i_fourcc;
433 if( ppsz_name ) *ppsz_name = vlc_fourcc_GetDescription( AUDIO_ES,
434 audio_format_table[i].i_fourcc );
435 return !!audio_format_table[i].i_fourcc;
436 }
437
438 static const char *GetOmxAudioRole( vlc_fourcc_t i_fourcc )
439 {
440 unsigned int i;
441
442 i_fourcc = vlc_fourcc_GetCodec( AUDIO_ES, i_fourcc );
443
444 for( i = 0; audio_format_table[i].i_codec != 0; i++ )
445 if( audio_format_table[i].i_fourcc == i_fourcc ) break;
446
447 return audio_format_table[i].psz_role;
448 }
449
450 static const char *GetOmxAudioEncRole( vlc_fourcc_t i_fourcc )
451 {
452 unsigned int i;
453
454 i_fourcc = vlc_fourcc_GetCodec( AUDIO_ES, i_fourcc );
455
456 for( i = 0; audio_enc_format_table[i].i_codec != 0; i++ )
457 if( audio_enc_format_table[i].i_fourcc == i_fourcc ) break;
458
459 return audio_enc_format_table[i].psz_role;
460 }
461
462 const char *GetOmxRole( vlc_fourcc_t i_fourcc, int i_cat, bool b_enc )
463 {
464 if(b_enc)
465 return i_cat == VIDEO_ES ?
466 GetOmxVideoEncRole( i_fourcc ) : GetOmxAudioEncRole( i_fourcc );
467 else
468 return i_cat == VIDEO_ES ?
469 GetOmxVideoRole( i_fourcc ) : GetOmxAudioRole( i_fourcc );
470 }
471
472 int GetOmxChromaFormat( vlc_fourcc_t i_fourcc,
473 OMX_COLOR_FORMATTYPE *pi_omx_codec,
474 const char **ppsz_name )
475 {
476 unsigned int i;
477
478 i_fourcc = vlc_fourcc_GetCodec( VIDEO_ES, i_fourcc );
479
480 for( i = 0; chroma_format_table[i].i_codec != 0; i++ )
481 if( chroma_format_table[i].i_fourcc == i_fourcc ) break;
482
483 if( pi_omx_codec ) *pi_omx_codec = chroma_format_table[i].i_codec;
484 if( ppsz_name ) *ppsz_name = vlc_fourcc_GetDescription( VIDEO_ES, i_fourcc );
485 return !!chroma_format_table[i].i_codec;
486 }
487
488 int GetVlcChromaFormat( OMX_COLOR_FORMATTYPE i_omx_codec,
489 vlc_fourcc_t *pi_fourcc, const char **ppsz_name )
490 {
491 unsigned int i;
492
493 for( i = 0; chroma_format_table[i].i_codec != 0; i++ )
494 if( chroma_format_table[i].i_codec == i_omx_codec ) break;
495
496 if( pi_fourcc ) *pi_fourcc = chroma_format_table[i].i_fourcc;
497 if( ppsz_name ) *ppsz_name = vlc_fourcc_GetDescription( VIDEO_ES,
498 chroma_format_table[i].i_fourcc );
499 return !!chroma_format_table[i].i_fourcc;
500 }
501
502 int GetVlcChromaSizes( vlc_fourcc_t i_fourcc,
503 unsigned int width, unsigned int height,
504 unsigned int *size, unsigned int *pitch,
505 unsigned int *chroma_pitch_div )
506 {
507 unsigned int i;
508
509 i_fourcc = vlc_fourcc_GetCodec( VIDEO_ES, i_fourcc );
510
511 for( i = 0; chroma_format_table[i].i_codec != 0; i++ )
512 if( chroma_format_table[i].i_fourcc == i_fourcc ) break;
513
514 /* Align on macroblock boundary */
515 width = (width + 15) & ~0xF;
516 height = (height + 15) & ~0xF;
517
518 if( size ) *size = width * height * chroma_format_table[i].i_size_mul / 2;
519 if( pitch ) *pitch = width * chroma_format_table[i].i_line_mul;
520 if( chroma_pitch_div )
521 *chroma_pitch_div = chroma_format_table[i].i_line_chroma_div;
522 return !!chroma_format_table[i].i_codec;
523 }
524
525 /*****************************************************************************
526 * Functions to deal with audio format parameters
527 *****************************************************************************/
528 static const struct {
529 OMX_AUDIO_CODINGTYPE encoding;
530 OMX_INDEXTYPE index;
531 int size;
532 } audio_encoding_param[] =
533 { { OMX_AUDIO_CodingPCM, OMX_IndexParamAudioPcm,
534 sizeof(OMX_AUDIO_PARAM_PCMMODETYPE) },
535 { OMX_AUDIO_CodingADPCM, OMX_IndexParamAudioAdpcm,
536 sizeof(OMX_AUDIO_PARAM_ADPCMTYPE) },
537 { OMX_AUDIO_CodingAMR, OMX_IndexParamAudioAmr,
538 sizeof(OMX_AUDIO_PARAM_AMRTYPE) },
539 { OMX_AUDIO_CodingG711, OMX_IndexParamAudioPcm,
540 sizeof(OMX_AUDIO_PARAM_PCMMODETYPE) },
541 { OMX_AUDIO_CodingG723, OMX_IndexParamAudioG723,
542 sizeof(OMX_AUDIO_PARAM_G723TYPE) },
543 { OMX_AUDIO_CodingG726, OMX_IndexParamAudioG726,
544 sizeof(OMX_AUDIO_PARAM_G726TYPE) },
545 { OMX_AUDIO_CodingG729, OMX_IndexParamAudioG729,
546 sizeof(OMX_AUDIO_PARAM_G729TYPE) },
547 { OMX_AUDIO_CodingAAC, OMX_IndexParamAudioAac,
548 sizeof(OMX_AUDIO_PARAM_AACPROFILETYPE) },
549 { OMX_AUDIO_CodingMP3, OMX_IndexParamAudioMp3,
550 sizeof(OMX_AUDIO_PARAM_MP3TYPE) },
551 { OMX_AUDIO_CodingSBC, OMX_IndexParamAudioSbc,
552 sizeof(OMX_AUDIO_PARAM_SBCTYPE) },
553 { OMX_AUDIO_CodingVORBIS, OMX_IndexParamAudioVorbis,
554 sizeof(OMX_AUDIO_PARAM_VORBISTYPE) },
555 { OMX_AUDIO_CodingWMA, OMX_IndexParamAudioWma,
556 sizeof(OMX_AUDIO_PARAM_WMATYPE) },
557 { OMX_AUDIO_CodingRA, OMX_IndexParamAudioRa,
558 sizeof(OMX_AUDIO_PARAM_RATYPE) },
559 { OMX_AUDIO_CodingUnused, 0, 0 }
560 };
561
562 static OMX_INDEXTYPE GetAudioParamFormatIndex(OMX_AUDIO_CODINGTYPE encoding)
563 {
564 int i;
565
566 for(i = 0; audio_encoding_param[i].encoding != OMX_AUDIO_CodingUnused &&
567 audio_encoding_param[i].encoding != encoding; i++);
568
569 return audio_encoding_param[i].index;
570 }
571
572 static unsigned int GetAudioParamSize(OMX_INDEXTYPE index)
573 {
574 int i;
575
576 for(i = 0; audio_encoding_param[i].encoding != OMX_AUDIO_CodingUnused &&
577 audio_encoding_param[i].index != index; i++);
578
579 return audio_encoding_param[i].size;
580 }
581
582 OMX_ERRORTYPE SetAudioParameters(OMX_HANDLETYPE handle,
583 OmxFormatParam *param, OMX_U32 i_port, OMX_AUDIO_CODINGTYPE encoding,
584 uint8_t i_channels, unsigned int i_samplerate, unsigned int i_bitrate,
585 unsigned int i_bps, unsigned int i_blocksize)
586 {
587 OMX_INDEXTYPE index;
588
589 switch(encoding)
590 {
591 case OMX_AUDIO_CodingPCM:
592 case OMX_AUDIO_CodingG711:
593 OMX_INIT_STRUCTURE(param->pcm);
594 param->pcm.nChannels = i_channels;
595 param->pcm.nSamplingRate = i_samplerate;
596 param->pcm.eNumData = OMX_NumericalDataSigned;
597 param->pcm.ePCMMode = OMX_AUDIO_PCMModeLinear;
598 param->pcm.eEndian = OMX_EndianLittle;
599 param->pcm.bInterleaved = OMX_TRUE;
600 param->pcm.nBitPerSample = i_bps;
601 param->pcm.eChannelMapping[0] = OMX_AUDIO_ChannelCF;
602 if(i_channels == 2)
603 {
604 param->pcm.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
605 param->pcm.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
606 }
607 break;
608 case OMX_AUDIO_CodingADPCM:
609 OMX_INIT_STRUCTURE(param->adpcm);
610 param->adpcm.nChannels = i_channels;
611 param->adpcm.nSampleRate = i_samplerate;
612 param->adpcm.nBitsPerSample = i_bps;
613 break;
614 case OMX_AUDIO_CodingAMR:
615 OMX_INIT_STRUCTURE(param->amr);
616 param->amr.nChannels = i_channels;
617 param->amr.nBitRate = i_bitrate;
618 param->amr.eAMRBandMode = OMX_AUDIO_AMRBandModeUnused;
619 param->amr.eAMRDTXMode = OMX_AUDIO_AMRDTXModeOff;
620 param->amr.eAMRFrameFormat = OMX_AUDIO_AMRFrameFormatConformance;
621 break;
622 case OMX_AUDIO_CodingG723:
623 OMX_INIT_STRUCTURE(param->g723);
624 param->g723.nChannels = i_channels;
625 param->g723.bDTX = OMX_FALSE;
626 param->g723.eBitRate = OMX_AUDIO_G723ModeUnused;
627 param->g723.bHiPassFilter = OMX_TRUE;
628 param->g723.bPostFilter = OMX_TRUE;
629 break;
630 case OMX_AUDIO_CodingG726:
631 OMX_INIT_STRUCTURE(param->g726);
632 param->g726.nChannels = i_channels;
633 param->g726.eG726Mode = OMX_AUDIO_G726ModeUnused;
634 break;
635 case OMX_AUDIO_CodingG729:
636 OMX_INIT_STRUCTURE(param->g729);
637 param->g729.nChannels = i_channels;
638 param->g729.bDTX = OMX_FALSE;
639 param->g729.eBitType = OMX_AUDIO_G729;
640 break;
641 case OMX_AUDIO_CodingAAC:
642 OMX_INIT_STRUCTURE(param->aac);
643 param->aac.nChannels = i_channels;
644 param->aac.nSampleRate = i_samplerate;
645 param->aac.nBitRate = i_bitrate;
646 param->aac.nAudioBandWidth = 0;
647 param->aac.nFrameLength = 1024;
648 param->aac.nAACtools = OMX_AUDIO_AACToolAll;
649 param->aac.nAACERtools = OMX_AUDIO_AACERAll;
650 param->aac.eAACProfile = OMX_AUDIO_AACObjectLC;
651 param->aac.eAACStreamFormat = OMX_AUDIO_AACStreamFormatRAW;
652 param->aac.eChannelMode = i_channels ?
653 OMX_AUDIO_ChannelModeStereo : OMX_AUDIO_ChannelModeMono;
654 break;
655 case OMX_AUDIO_CodingMP3:
656 OMX_INIT_STRUCTURE(param->mp3);
657 param->mp3.nChannels = i_channels;
658 param->mp3.nSampleRate = i_samplerate;
659 param->mp3.nBitRate = i_bitrate;
660 param->mp3.eChannelMode = i_channels ?
661 OMX_AUDIO_ChannelModeStereo : OMX_AUDIO_ChannelModeMono;
662 param->mp3.eFormat = OMX_AUDIO_MP3StreamFormatMP1Layer3;
663 break;
664 case OMX_AUDIO_CodingWMA:
665 OMX_INIT_STRUCTURE(param->wma);
666 param->wma.nChannels = i_channels;
667 param->wma.nBitRate = i_bitrate;
668 param->wma.eFormat = OMX_AUDIO_WMAFormatUnused;
669 param->wma.eProfile = OMX_AUDIO_WMAProfileUnused;
670 param->wma.nSamplingRate = i_samplerate;
671 param->wma.nBlockAlign = i_blocksize;
672 param->wma.nEncodeOptions = 0;
673 param->wma.nSuperBlockAlign = 0;
674 break;
675 case OMX_AUDIO_CodingRA:
676 OMX_INIT_STRUCTURE(param->ra);
677 param->ra.nChannels = i_channels;
678 param->ra.nSamplingRate = i_samplerate;
679 param->ra.nBitsPerFrame = i_bps;
680 param->ra.nSamplePerFrame = 0;
681 param->ra.nCouplingQuantBits = 0;
682 param->ra.nCouplingStartRegion = 0;
683 param->ra.nNumRegions = 0;
684 param->ra.eFormat = OMX_AUDIO_RAFormatUnused;
685 break;
686 case OMX_AUDIO_CodingVORBIS:
687 OMX_INIT_STRUCTURE(param->vorbis);
688 param->vorbis.nChannels = i_channels;
689 param->vorbis.nBitRate = i_bitrate;
690 param->vorbis.nMinBitRate = 0;
691 param->vorbis.nMaxBitRate = i_bitrate;
692 param->vorbis.nSampleRate = i_samplerate;
693 param->vorbis.nAudioBandWidth = 0;
694 param->vorbis.nQuality = 3;
695 param->vorbis.bManaged = OMX_FALSE;
696 param->vorbis.bDownmix = OMX_FALSE;
697 break;
698 default:
699 return OMX_ErrorBadParameter;
700 }
701
702 param->common.nPortIndex = i_port;
703
704 index = GetAudioParamFormatIndex(encoding);
705 return OMX_SetParameter(handle, index, param);
706 }
707
708 OMX_ERRORTYPE GetAudioParameters(OMX_HANDLETYPE handle,
709 OmxFormatParam *param, OMX_U32 i_port, OMX_AUDIO_CODINGTYPE encoding,
710 uint8_t *pi_channels, unsigned int *pi_samplerate,
711 unsigned int *pi_bitrate, unsigned int *pi_bps, unsigned int *pi_blocksize)
712 {
713 int i_channels = 0, i_samplerate = 0, i_bitrate = 0;
714 int i_bps = 0, i_blocksize = 0;
715 OMX_ERRORTYPE omx_error;
716 OMX_INDEXTYPE index;
717
718 OMX_INIT_COMMON(param->common);
719 param->common.nPortIndex = i_port;
720 index = GetAudioParamFormatIndex(encoding);
721 if(!index) return OMX_ErrorNotImplemented;
722
723 param->common.nSize = GetAudioParamSize(index);
724 omx_error = OMX_GetParameter(handle, index, param);
725 if(omx_error != OMX_ErrorNone) return omx_error;
726
727 switch(encoding)
728 {
729 case OMX_AUDIO_CodingPCM:
730 case OMX_AUDIO_CodingG711:
731 i_channels = param->pcm.nChannels;
732 i_samplerate = param->pcm.nSamplingRate;
733 i_bps = param->pcm.nBitPerSample;
734 break;
735 case OMX_AUDIO_CodingADPCM:
736 i_channels = param->adpcm.nChannels;
737 i_samplerate = param->adpcm.nSampleRate;
738 i_bps = param->adpcm.nBitsPerSample;
739 break;
740 case OMX_AUDIO_CodingAMR:
741 i_channels = param->amr.nChannels;
742 i_bitrate = param->amr.nBitRate;
743 i_samplerate = 8000;
744 break;
745 case OMX_AUDIO_CodingG723:
746 i_channels = param->g723.nChannels;
747 break;
748 case OMX_AUDIO_CodingG726:
749 i_channels = param->g726.nChannels;
750 break;
751 case OMX_AUDIO_CodingG729:
752 i_channels = param->g729.nChannels;
753 break;
754 case OMX_AUDIO_CodingAAC:
755 i_channels = param->aac.nChannels;
756 i_samplerate = param->aac.nSampleRate;
757 i_bitrate = param->aac.nBitRate;
758 i_channels = param->aac.eChannelMode == OMX_AUDIO_ChannelModeStereo ? 2 : 1;
759 break;
760 case OMX_AUDIO_CodingMP3:
761 i_channels = param->mp3.nChannels;
762 i_samplerate = param->mp3.nSampleRate;
763 i_bitrate = param->mp3.nBitRate;
764 i_channels = param->mp3.eChannelMode == OMX_AUDIO_ChannelModeStereo ? 2 : 1;
765 break;
766 case OMX_AUDIO_CodingVORBIS:
767 i_channels = param->vorbis.nChannels;
768 i_bitrate = param->vorbis.nBitRate;
769 i_samplerate = param->vorbis.nSampleRate;
770 break;
771 case OMX_AUDIO_CodingWMA:
772 i_channels = param->wma.nChannels;
773 i_bitrate = param->wma.nBitRate;
774 i_samplerate = param->wma.nSamplingRate;
775 i_blocksize = param->wma.nBlockAlign;
776 break;
777 case OMX_AUDIO_CodingRA:
778 i_channels = param->ra.nChannels;
779 i_samplerate = param->ra.nSamplingRate;
780 i_bps = param->ra.nBitsPerFrame;
781 break;
782 default:
783 return OMX_ErrorBadParameter;
784 }
785
786 if(pi_channels) *pi_channels = i_channels;
787 if(pi_samplerate) *pi_samplerate = i_samplerate;
788 if(pi_bitrate) *pi_bitrate = i_bitrate;
789 if(pi_bps) *pi_bps = i_bps;
790 if(pi_blocksize) *pi_blocksize = i_blocksize;
791 return OMX_ErrorNone;
792 }
793
794 /*****************************************************************************
795 * PrintOmx: print component summary
796 *****************************************************************************/
797 void PrintOmx(decoder_t *p_dec, OMX_HANDLETYPE omx_handle, OMX_U32 i_port)
798 {
799 OMX_PARAM_PORTDEFINITIONTYPE definition;
800 OMX_PORT_PARAM_TYPE param;
801 OMX_ERRORTYPE omx_error;
802 unsigned int i, j;
803
804 /* Find the input / output ports */
805 OMX_INIT_STRUCTURE(param);
806 OMX_INIT_STRUCTURE(definition);
807
808 for(i = 0; i < 3; i++)
809 {
810 omx_error = OMX_GetParameter(omx_handle, OMX_IndexParamAudioInit + i, &param);
811 if(omx_error != OMX_ErrorNone) continue;
812
813 if(i_port == OMX_ALL)
814 msg_Dbg( p_dec, "found %i %s ports", (int)param.nPorts,
815 i == 0 ? "audio" : i == 1 ? "image" : "video" );
816
817 for(j = 0; j < param.nPorts; j++)
818 {
819 unsigned int i_samplerate, i_bitrate;
820 unsigned int i_bitspersample, i_blockalign;
821 uint8_t i_channels;
822 OmxFormatParam format_param;
823 vlc_fourcc_t i_fourcc;
824 const char *psz_name;
825
826 if(i_port != OMX_ALL && i_port != param.nStartPortNumber + j)
827 continue;
828
829 /* Get port definition */
830 definition.nPortIndex = param.nStartPortNumber + j;
831 omx_error = OMX_GetParameter(omx_handle, OMX_IndexParamPortDefinition,
832 &definition);
833 if(omx_error != OMX_ErrorNone) continue;
834
835 OMX_PARAM_U32TYPE u32param;
836 OMX_INIT_STRUCTURE(u32param);
837 u32param.nPortIndex = param.nStartPortNumber + j;
838 omx_error = OMX_GetParameter(omx_handle, OMX_IndexParamNumAvailableStreams,
839 (OMX_PTR)&u32param);
840
841 msg_Dbg( p_dec, "-> %s %i (%i streams) (%i:%i:%i buffers) (%i,%i) %s",
842 definition.eDir == OMX_DirOutput ? "output" : "input",
843 (int)definition.nPortIndex, (int)u32param.nU32,
844 (int)definition.nBufferCountActual,
845 (int)definition.nBufferCountMin, (int)definition.nBufferSize,
846 (int)definition.bBuffersContiguous,
847 (int)definition.nBufferAlignment,
848 definition.bEnabled ? "enabled" : "disabled" );
849
850 switch(definition.eDomain)
851 {
852 case OMX_PortDomainVideo:
853
854 if(definition.format.video.eCompressionFormat)
855 GetVlcVideoFormat( definition.format.video.eCompressionFormat,
856 &i_fourcc, &psz_name );
857 else
858 GetVlcChromaFormat( definition.format.video.eColorFormat,
859 &i_fourcc, &psz_name );
860
861 msg_Dbg( p_dec, " -> video %s %ix%i@%.2f (%i,%i) (%i,%i)", psz_name,
862 (int)definition.format.video.nFrameWidth,
863 (int)definition.format.video.nFrameHeight,
864 (float)definition.format.video.xFramerate/(float)(1<<16),
865 (int)definition.format.video.eCompressionFormat,
866 (int)definition.format.video.eColorFormat,
867 (int)definition.format.video.nStride,
868 (int)definition.format.video.nSliceHeight);
869 break;
870
871 case OMX_PortDomainAudio:
872
873 GetVlcAudioFormat( definition.format.audio.eEncoding,
874 &i_fourcc, &psz_name );
875
876 GetAudioParameters(omx_handle, &format_param,
877 definition.nPortIndex,
878 definition.format.audio.eEncoding,
879 &i_channels, &i_samplerate, &i_bitrate,
880 &i_bitspersample, &i_blockalign);
881
882 msg_Dbg( p_dec, " -> audio %s (%i) %i,%i,%i,%i,%i", psz_name,
883 (int)definition.format.audio.eEncoding,
884 i_channels, i_samplerate, i_bitrate, i_bitspersample,
885 i_blockalign);
886 break;
887
888 default: break;
889 }
890 }
891 }
892 }