git.sesse.net Git - vlc/blob - modules/codec/mmal.c

   1 /*****************************************************************************
   2  * mmal.c: MMAL-based decoder plugin for Raspberry Pi
   3  *****************************************************************************
   4  * Copyright © 2014 jusst technologies GmbH
   5  * $Id$
   6  *
   7  * Authors: Dennis Hamester <dennis.hamester@gmail.com>
   8  *          Julian Scheel <julian@jusst.de>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include "config.h"
  27 #endif
  28
  29 #include <vlc_common.h>
  30 #include <vlc_plugin.h>
  31 #include <vlc_codec.h>
  32 #include <vlc_threads.h>
  33
  34 #include <bcm_host.h>
  35 #include <interface/mmal/mmal.h>
  36 #include <interface/mmal/util/mmal_util.h>
  37 #include <interface/mmal/util/mmal_default_components.h>
  38
  39 /* This value must match the define in video_output/mmal.c
  40  * Think twice before changing this. Incorrect values cause havoc.
  41  */
  42 #define NUM_ACTUAL_OPAQUE_BUFFERS 40
  43
  44 #define NUM_EXTRA_BUFFERS 10
  45 #define NUM_OPAQUE_BUFFERS 20
  46
  47 #define MIN_NUM_BUFFERS_IN_TRANSIT 2
  48
  49 #define MMAL_ZEROCOPY_NAME "mmal-zerocopy"
  50 #define MMAL_ZEROCOPY_TEXT N_("Decode frames directly into RPI VideoCore instead of host memory.")
  51 #define MMAL_ZEROCOPY_LONGTEXT N_("Decode frames directly into RPI VideoCore instead of host memory. This option must only be used with the MMAL video output plugin.")
  52
  53 static int OpenDecoder(decoder_t *dec);
  54 static void CloseDecoder(decoder_t *dec);
  55
  56 vlc_module_begin()
  57     set_shortname(N_("MMAL decoder"))
  58     set_description(N_("MMAL-based decoder plugin for Raspberry Pi"))
  59     set_capability("decoder", 90)
  60     add_shortcut("mmal_decoder")
  61     add_bool(MMAL_ZEROCOPY_NAME, true, MMAL_ZEROCOPY_TEXT, MMAL_ZEROCOPY_LONGTEXT, false)
  62     set_callbacks(OpenDecoder, CloseDecoder)
  63 vlc_module_end()
  64
  65 struct decoder_sys_t {
  66     bool opaque;
  67     MMAL_COMPONENT_T *component;
  68     MMAL_PORT_T *input;
  69     MMAL_POOL_T *input_pool;
  70     MMAL_PORT_T *output;
  71     MMAL_POOL_T *output_pool;
  72     MMAL_ES_FORMAT_T *output_format;
  73     MMAL_QUEUE_T *decoded_pictures;
  74     vlc_mutex_t mutex;
  75 };
  76
  77 /* Utilities */
  78 static int change_output_format(decoder_t *dec);
  79 static int send_output_buffer(decoder_t *dec);
  80 static void fill_output_port(decoder_t *dec);
  81
  82 /* VLC decoder callback */
  83 static picture_t *decode(decoder_t *dec, block_t **block);
  84
  85 /* MMAL callbacks */
  86 static void control_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer);
  87 static void input_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer);
  88 static void output_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer);
  89
  90 static int OpenDecoder(decoder_t *dec)
  91 {
  92     int ret = VLC_SUCCESS;
  93     decoder_sys_t *sys;
  94     MMAL_PARAMETER_BOOLEAN_T error_concealment;
  95     MMAL_PARAMETER_UINT32_T extra_buffers;
  96     MMAL_STATUS_T status;
  97
  98     if (dec->fmt_in.i_cat != VIDEO_ES)
  99         return VLC_EGENERIC;
 100
 101     if (dec->fmt_in.i_codec != VLC_CODEC_MPGV &&
 102             dec->fmt_in.i_codec != VLC_CODEC_H264)
 103         return VLC_EGENERIC;
 104
 105     sys = calloc(1, sizeof(decoder_sys_t));
 106     if (!sys) {
 107         ret = VLC_ENOMEM;
 108         goto out;
 109     }
 110     dec->p_sys = sys;
 111     dec->b_need_packetized = true;
 112
 113     sys->opaque = var_InheritBool(dec, MMAL_ZEROCOPY_NAME);
 114     bcm_host_init();
 115
 116     status = mmal_component_create(MMAL_COMPONENT_DEFAULT_VIDEO_DECODER, &sys->component);
 117     if (status != MMAL_SUCCESS) {
 118         msg_Err(dec, "Failed to create MMAL component %s (status=%"PRIx32" %s)",
 119                 MMAL_COMPONENT_DEFAULT_VIDEO_DECODER, status, mmal_status_to_string(status));
 120         ret = VLC_EGENERIC;
 121         goto out;
 122     }
 123
 124     sys->component->control->userdata = (struct MMAL_PORT_USERDATA_T *)dec;
 125     status = mmal_port_enable(sys->component->control, control_port_cb);
 126     if (status != MMAL_SUCCESS) {
 127         msg_Err(dec, "Failed to enable control port %s (status=%"PRIx32" %s)",
 128                 sys->component->control->name, status, mmal_status_to_string(status));
 129         ret = VLC_EGENERIC;
 130         goto out;
 131     }
 132
 133     sys->input = sys->component->input[0];
 134     sys->input->userdata = (struct MMAL_PORT_USERDATA_T *)dec;
 135     if (dec->fmt_in.i_codec == VLC_CODEC_MPGV)
 136         sys->input->format->encoding = MMAL_ENCODING_MP2V;
 137     else
 138         sys->input->format->encoding = MMAL_ENCODING_H264;
 139
 140     if (dec->fmt_in.i_codec == VLC_CODEC_H264) {
 141         if (dec->fmt_in.i_extra > 0) {
 142             status = mmal_format_extradata_alloc(sys->input->format,
 143                     dec->fmt_in.i_extra);
 144             if (status == MMAL_SUCCESS) {
 145                 memcpy(sys->input->format->extradata, dec->fmt_in.p_extra,
 146                         dec->fmt_in.i_extra);
 147                 sys->input->format->extradata_size = dec->fmt_in.i_extra;
 148             } else {
 149                 msg_Err(dec, "Failed to allocate extra format data on input port %s (status=%"PRIx32" %s)",
 150                         sys->input->name, status, mmal_status_to_string(status));
 151             }
 152         } else {
 153             error_concealment.hdr.id = MMAL_PARAMETER_VIDEO_DECODE_ERROR_CONCEALMENT;
 154             error_concealment.hdr.size = sizeof(MMAL_PARAMETER_BOOLEAN_T);
 155             error_concealment.enable = MMAL_FALSE;
 156             status = mmal_port_parameter_set(sys->input, &error_concealment.hdr);
 157             if (status != MMAL_SUCCESS)
 158                 msg_Err(dec, "Failed to disable error concealment (status=%"PRIx32" %s)",
 159                         status, mmal_status_to_string(status));
 160         }
 161     }
 162
 163     status = mmal_port_format_commit(sys->input);
 164     if (status != MMAL_SUCCESS) {
 165         msg_Err(dec, "Failed to commit format for input port %s (status=%"PRIx32" %s)",
 166                 sys->input->name, status, mmal_status_to_string(status));
 167         ret = VLC_EGENERIC;
 168         goto out;
 169     }
 170     sys->input->buffer_size = sys->input->buffer_size_recommended;
 171     sys->input->buffer_num = __MAX(sys->input->buffer_num_recommended, 80);
 172
 173     status = mmal_port_enable(sys->input, input_port_cb);
 174     if (status != MMAL_SUCCESS) {
 175         msg_Err(dec, "Failed to enable input port %s (status=%"PRIx32" %s)",
 176                 sys->input->name, status, mmal_status_to_string(status));
 177         ret = VLC_EGENERIC;
 178         goto out;
 179     }
 180
 181     sys->output = sys->component->output[0];
 182     sys->output->userdata = (struct MMAL_PORT_USERDATA_T *)dec;
 183
 184     if (sys->opaque) {
 185         extra_buffers.hdr.id = MMAL_PARAMETER_EXTRA_BUFFERS;
 186         extra_buffers.hdr.size = sizeof(MMAL_PARAMETER_UINT32_T);
 187         extra_buffers.value = NUM_ACTUAL_OPAQUE_BUFFERS - NUM_OPAQUE_BUFFERS;
 188         status = mmal_port_parameter_set(sys->output, &extra_buffers.hdr);
 189         if (status != MMAL_SUCCESS) {
 190             msg_Err(dec, "Failed to set MMAL_PARAMETER_EXTRA_BUFFERS on output port (status=%"PRIx32" %s)",
 191                     status, mmal_status_to_string(status));
 192             ret = VLC_EGENERIC;
 193             goto out;
 194         }
 195     }
 196
 197     status = mmal_port_enable(sys->output, output_port_cb);
 198     if (status != MMAL_SUCCESS) {
 199         msg_Err(dec, "Failed to enable output port %s (status=%"PRIx32" %s)",
 200                 sys->output->name, status, mmal_status_to_string(status));
 201         ret = VLC_EGENERIC;
 202         goto out;
 203     }
 204
 205     status = mmal_component_enable(sys->component);
 206     if (status != MMAL_SUCCESS) {
 207         msg_Err(dec, "Failed to enable component %s (status=%"PRIx32" %s)",
 208                 sys->component->name, status, mmal_status_to_string(status));
 209         ret = VLC_EGENERIC;
 210         goto out;
 211     }
 212
 213     sys->input_pool = mmal_pool_create(sys->input->buffer_num, 0);
 214     sys->decoded_pictures = mmal_queue_create();
 215
 216     if (sys->opaque) {
 217         dec->fmt_out.i_codec = VLC_CODEC_MMAL_OPAQUE;
 218         dec->fmt_out.video.i_chroma = VLC_CODEC_MMAL_OPAQUE;
 219     } else {
 220         dec->fmt_out.i_codec = VLC_CODEC_I420;
 221         dec->fmt_out.video.i_chroma = VLC_CODEC_I420;
 222     }
 223
 224     dec->fmt_out.i_cat = VIDEO_ES;
 225     dec->pf_decode_video = decode;
 226
 227     vlc_mutex_init_recursive(&sys->mutex);
 228
 229 out:
 230     if (ret != VLC_SUCCESS)
 231         CloseDecoder(dec);
 232
 233     return ret;
 234 }
 235
 236 static void CloseDecoder(decoder_t *dec)
 237 {
 238     decoder_sys_t *sys = dec->p_sys;
 239     MMAL_BUFFER_HEADER_T *buffer;
 240
 241     if (!sys)
 242         return;
 243
 244     if (sys->component && sys->component->control->is_enabled)
 245         mmal_port_disable(sys->component->control);
 246
 247     if (sys->input && sys->input->is_enabled)
 248         mmal_port_disable(sys->input);
 249
 250     if (sys->output && sys->output->is_enabled)
 251         mmal_port_disable(sys->output);
 252
 253     if (sys->component && sys->component->is_enabled)
 254         mmal_component_disable(sys->component);
 255
 256     if (sys->input_pool)
 257         mmal_pool_destroy(sys->input_pool);
 258
 259     if (sys->output_format)
 260         mmal_format_free(sys->output_format);
 261
 262     /* Free pictures which are decoded but have not yet been sent
 263      * out to the core */
 264     while (buffer = mmal_queue_get(sys->decoded_pictures)) {
 265         picture_t *pic = (picture_t *)buffer->user_data;
 266         picture_Release(pic);
 267
 268         buffer->user_data = NULL;
 269         buffer->alloc_size = 0;
 270         buffer->data = NULL;
 271         mmal_buffer_header_release(buffer);
 272     }
 273
 274     if (sys->decoded_pictures)
 275         mmal_queue_destroy(sys->decoded_pictures);
 276
 277     if (sys->output_pool)
 278         mmal_pool_destroy(sys->output_pool);
 279
 280     if (sys->component)
 281         mmal_component_release(sys->component);
 282
 283     free(sys);
 284
 285     bcm_host_deinit();
 286 }
 287
 288 static int change_output_format(decoder_t *dec)
 289 {
 290     decoder_sys_t *sys = dec->p_sys;
 291     MMAL_STATUS_T status;
 292     int pool_size;
 293     int ret = 0;
 294
 295     status = mmal_port_disable(sys->output);
 296     if (status != MMAL_SUCCESS) {
 297         msg_Err(dec, "Failed to disable output port (status=%"PRIx32" %s)",
 298                 status, mmal_status_to_string(status));
 299         ret = -1;
 300         goto out;
 301     }
 302
 303     mmal_format_full_copy(sys->output->format, sys->output_format);
 304     status = mmal_port_format_commit(sys->output);
 305     if (status != MMAL_SUCCESS) {
 306         msg_Err(dec, "Failed to commit output format (status=%"PRIx32" %s)",
 307                 status, mmal_status_to_string(status));
 308         ret = -1;
 309         goto out;
 310     }
 311
 312     if (sys->opaque) {
 313         sys->output->buffer_num = NUM_ACTUAL_OPAQUE_BUFFERS;
 314         pool_size = sys->output->buffer_num_recommended + NUM_EXTRA_BUFFERS;
 315     } else {
 316         sys->output->buffer_num = __MAX(sys->output->buffer_num_recommended,
 317                 MIN_NUM_BUFFERS_IN_TRANSIT);
 318         pool_size = sys->output->buffer_num + NUM_EXTRA_BUFFERS;
 319     }
 320
 321     sys->output->buffer_size = sys->output->buffer_size_recommended;
 322
 323     status = mmal_port_enable(sys->output, output_port_cb);
 324     if (status != MMAL_SUCCESS) {
 325         msg_Err(dec, "Failed to enable output port (status=%"PRIx32" %s)",
 326                 status, mmal_status_to_string(status));
 327         ret = -1;
 328         goto out;
 329     }
 330
 331     if (!sys->output_pool) {
 332         sys->output_pool = mmal_pool_create(pool_size, 0);
 333         msg_Dbg(dec, "Created output pool with %d pictures", sys->output_pool->headers_num);
 334
 335         dec->i_extra_picture_buffers = sys->output_pool->headers_num;
 336
 337         if (dec->fmt_in.i_codec == VLC_CODEC_H264)
 338             dec->i_extra_picture_buffers -= 16;
 339         else
 340             dec->i_extra_picture_buffers -= 4;
 341
 342         dec->i_extra_picture_buffers = __MAX(dec->i_extra_picture_buffers,
 343                 MIN_NUM_BUFFERS_IN_TRANSIT + 1);
 344         msg_Dbg(dec, "Request %d extra pictures", dec->i_extra_picture_buffers);
 345     }
 346
 347     dec->fmt_out.video.i_width = sys->output->format->es->video.width;
 348     dec->fmt_out.video.i_height = sys->output->format->es->video.height;
 349     dec->fmt_out.video.i_x_offset = sys->output->format->es->video.crop.x;
 350     dec->fmt_out.video.i_y_offset = sys->output->format->es->video.crop.y;
 351     dec->fmt_out.video.i_visible_width = sys->output->format->es->video.crop.width;
 352     dec->fmt_out.video.i_visible_height = sys->output->format->es->video.crop.height;
 353     dec->fmt_out.video.i_sar_num = sys->output->format->es->video.par.num;
 354     dec->fmt_out.video.i_sar_den = sys->output->format->es->video.par.den;
 355     dec->fmt_out.video.i_frame_rate = sys->output->format->es->video.frame_rate.num;
 356     dec->fmt_out.video.i_frame_rate_base = sys->output->format->es->video.frame_rate.den;
 357
 358
 359 out:
 360     mmal_format_free(sys->output_format);
 361     sys->output_format = NULL;
 362
 363     return ret;
 364 }
 365
 366 static int send_output_buffer(decoder_t *dec)
 367 {
 368     decoder_sys_t *sys = dec->p_sys;
 369     MMAL_BUFFER_HEADER_T *buffer;
 370     picture_t *picture;
 371     MMAL_STATUS_T status;
 372     int ret = 0;
 373
 374     buffer = mmal_queue_get(sys->output_pool->queue);
 375     if (!buffer) {
 376         msg_Warn(dec, "Failed to get new buffer");
 377         ret = -1;
 378         goto out;
 379     }
 380
 381     picture = decoder_NewPicture(dec);
 382     if (!picture) {
 383         msg_Warn(dec, "Failed to get new picture");
 384         mmal_buffer_header_release(buffer);
 385         ret = -1;
 386         goto out;
 387     }
 388
 389     mmal_buffer_header_reset(buffer);
 390     buffer->user_data = picture;
 391     buffer->cmd = 0;
 392     buffer->alloc_size = sys->output->buffer_size;
 393     buffer->data = picture->p[0].p_pixels;
 394
 395     status = mmal_port_send_buffer(sys->output, buffer);
 396     if (status != MMAL_SUCCESS) {
 397         msg_Err(dec, "Failed to send buffer to output port (status=%"PRIx32" %s)",
 398                 status, mmal_status_to_string(status));
 399         mmal_buffer_header_release(buffer);
 400         decoder_DeletePicture(dec, picture);
 401         ret = -1;
 402         goto out;
 403     }
 404
 405 out:
 406     return ret;
 407 }
 408
 409 static void fill_output_port(decoder_t *dec)
 410 {
 411     decoder_sys_t *sys = dec->p_sys;
 412     /* allow at least 2 buffers in transit */
 413     unsigned max_buffers_in_transit = __MAX(sys->output->buffer_num_recommended,
 414             MIN_NUM_BUFFERS_IN_TRANSIT);
 415     unsigned buffers_available = mmal_queue_length(sys->output_pool->queue);
 416     unsigned buffers_in_transit = sys->output_pool->headers_num - buffers_available -
 417         mmal_queue_length(sys->decoded_pictures);
 418     unsigned buffers_to_send = max_buffers_in_transit - buffers_in_transit;
 419     unsigned i;
 420
 421     if (buffers_to_send > buffers_available)
 422         buffers_to_send = buffers_available;
 423
 424 #ifndef NDEBUG
 425     msg_Dbg(dec, "Send %d buffers to output port (available: %d, in_transit: %d, buffer_num: %d)",
 426                     buffers_to_send, buffers_available, buffers_in_transit,
 427                     sys->output->buffer_num);
 428 #endif
 429     for (i = 0; i < buffers_to_send; ++i)
 430         if (send_output_buffer(dec) < 0)
 431             break;
 432 }
 433
 434 static picture_t *decode(decoder_t *dec, block_t **pblock)
 435 {
 436     decoder_sys_t *sys = dec->p_sys;
 437     block_t *block;
 438     MMAL_BUFFER_HEADER_T *buffer;
 439     uint32_t len;
 440     uint32_t flags = 0;
 441     MMAL_STATUS_T status;
 442     picture_t *ret = NULL;
 443
 444     /*
 445      * Configure output port if necessary
 446      */
 447     if (sys->output_format) {
 448         vlc_mutex_lock(&sys->mutex);
 449         if (change_output_format(dec) < 0)
 450             msg_Err(dec, "Failed to change output port format");
 451         vlc_mutex_unlock(&sys->mutex);
 452     }
 453
 454     /*
 455      * Send output buffers
 456      */
 457     if (sys->output_pool) {
 458         vlc_mutex_lock(&sys->mutex);
 459         buffer = mmal_queue_get(sys->decoded_pictures);
 460         if (buffer) {
 461             ret = (picture_t *)buffer->user_data;
 462             ret->date = buffer->pts;
 463
 464             buffer->user_data = NULL;
 465             buffer->alloc_size = 0;
 466             buffer->data = NULL;
 467             mmal_buffer_header_release(buffer);
 468         }
 469
 470         fill_output_port(dec);
 471         vlc_mutex_unlock(&sys->mutex);
 472     }
 473
 474     if (ret)
 475         goto out;
 476
 477     /*
 478      * Process input
 479      */
 480     if (!pblock)
 481         goto out;
 482
 483     block = *pblock;
 484
 485     if (!block)
 486         goto out;
 487
 488     *pblock = NULL;
 489
 490     if (block->i_flags & BLOCK_FLAG_CORRUPTED)
 491         flags |= MMAL_BUFFER_HEADER_FLAG_CORRUPTED;
 492
 493     if (block->i_flags & BLOCK_FLAG_DISCONTINUITY)
 494         flags |= MMAL_BUFFER_HEADER_FLAG_DISCONTINUITY;
 495
 496     vlc_mutex_lock(&sys->mutex);
 497     while (block->i_buffer > 0) {
 498         buffer = mmal_queue_timedwait(sys->input_pool->queue, 2);
 499         if (!buffer) {
 500             msg_Err(dec, "Failed to retrieve buffer header for input data");
 501             break;
 502         }
 503         mmal_buffer_header_reset(buffer);
 504         buffer->cmd = 0;
 505         buffer->pts = block->i_pts;
 506         buffer->dts = block->i_dts;
 507         buffer->alloc_size = sys->input->buffer_size;
 508
 509         len = block->i_buffer;
 510         if (len > buffer->alloc_size)
 511             len = buffer->alloc_size;
 512
 513         buffer->data = block->p_buffer;
 514         block->p_buffer += len;
 515         block->i_buffer -= len;
 516         buffer->length = len;
 517         if (block->i_buffer == 0)
 518             buffer->user_data = block;
 519         buffer->flags = flags;
 520
 521         status = mmal_port_send_buffer(sys->input, buffer);
 522         if (status != MMAL_SUCCESS) {
 523             msg_Err(dec, "Failed to send buffer to input port (status=%"PRIx32" %s)",
 524                     status, mmal_status_to_string(status));
 525             break;
 526         }
 527     }
 528     vlc_mutex_unlock(&sys->mutex);
 529
 530 out:
 531     return ret;
 532 }
 533
 534 static void control_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
 535 {
 536     decoder_t *dec = (decoder_t *)port->userdata;
 537     MMAL_STATUS_T status;
 538
 539     if (buffer->cmd == MMAL_EVENT_ERROR) {
 540         status = *(uint32_t *)buffer->data;
 541         msg_Err(dec, "MMAL error %"PRIx32" \"%s\"", status,
 542                 mmal_status_to_string(status));
 543     }
 544
 545     mmal_buffer_header_release(buffer);
 546 }
 547
 548 static void input_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
 549 {
 550     block_t *block = (block_t *)buffer->user_data;
 551     decoder_t *dec = (decoder_t *)port->userdata;
 552     decoder_sys_t *sys = dec->p_sys;
 553     buffer->user_data = NULL;
 554
 555     mmal_buffer_header_release(buffer);
 556     vlc_mutex_lock(&sys->mutex);
 557     if (block)
 558         block_Release(block);
 559     vlc_mutex_unlock(&sys->mutex);
 560 }
 561
 562 static void output_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
 563 {
 564     decoder_t *dec = (decoder_t *)port->userdata;
 565     decoder_sys_t *sys = dec->p_sys;
 566     picture_t *picture;
 567     MMAL_EVENT_FORMAT_CHANGED_T *fmt;
 568     MMAL_ES_FORMAT_T *format;
 569
 570     vlc_mutex_lock(&sys->mutex);
 571     if (buffer->cmd == 0) {
 572         if (buffer->length > 0) {
 573             mmal_queue_put(sys->decoded_pictures, buffer);
 574             fill_output_port(dec);
 575         } else {
 576             picture = (picture_t *)buffer->user_data;
 577             decoder_DeletePicture(dec, picture);
 578             buffer->user_data = NULL;
 579             buffer->alloc_size = 0;
 580             buffer->data = NULL;
 581             mmal_buffer_header_release(buffer);
 582         }
 583     } else if (buffer->cmd == MMAL_EVENT_FORMAT_CHANGED) {
 584         fmt = mmal_event_format_changed_get(buffer);
 585
 586         format = mmal_format_alloc();
 587         mmal_format_full_copy(format, fmt->format);
 588
 589         if (sys->opaque)
 590             format->encoding = MMAL_ENCODING_OPAQUE;
 591
 592         sys->output_format = format;
 593
 594         mmal_buffer_header_release(buffer);
 595     } else {
 596         mmal_buffer_header_release(buffer);
 597     }
 598     vlc_mutex_unlock(&sys->mutex);
 599 }