Ticket #2970: MediaEncoder.diff

File MediaEncoder.diff, 5.7 KB (added by BeSman, 10 years ago)

This is a patch which implements BMediaEncoder classes, sorry but I cant test it becose found only one app which using it - PersonalStudio, and its crash somewhere else...maybe try to compile haiku media kit on BeOS and test it there...

  • src/kits/media/MediaEncoder.cpp

     
    1 /***********************************************************************
    2  * AUTHOR: Marcus Overhagen
    3  *   FILE: MediaEncoder.cpp
    4  *  DESCR:
    5  ***********************************************************************/
     1/*
     2 * Copyright 2004-2007, Marcus Overhagen. All rights reserved.
     3 * Copyright 2010, Oleg Krysenkov, beos344@mail.ru.
     4 *
     5 * Distributed under the terms of the MIT License.
     6 */
     7 
    68#include <MediaEncoder.h>
     9#include <EncoderPlugin.h>
     10#include <PluginManager.h>
     11#include <new>
    712#include "debug.h"
    813
    914
     
    1217 *************************************************************/
    1318
    1419BMediaEncoder::BMediaEncoder()
     20    :   fEncoder(NULL),
     21        fInitStatus(B_NO_ERROR)
    1522{
    1623    UNIMPLEMENTED();
    1724}
    1825
    1926
    2027BMediaEncoder::BMediaEncoder(const media_format *output_format)
     28    :   fEncoder(NULL),
     29        fInitStatus(B_NO_ERROR)
    2130{
    2231    UNIMPLEMENTED();
    2332}
    2433
    2534
    2635BMediaEncoder::BMediaEncoder(const media_codec_info *mci)
     36    :   fEncoder(NULL),
     37        fInitStatus(B_NO_ERROR)
    2738{
    2839    UNIMPLEMENTED();
    2940}
     
    3243/* virtual */
    3344BMediaEncoder::~BMediaEncoder()
    3445{
    35     UNIMPLEMENTED();
     46    _plugin_manager.DestroyEncoder(fEncoder);
     47    fEncoder = NULL;
    3648}
    3749
    3850
    3951status_t
    4052BMediaEncoder::InitCheck() const
    4153{
    42     UNIMPLEMENTED();
    43 
    44     return B_OK;
     54    return fInitStatus;
    4555}
    4656
    4757status_t
    4858BMediaEncoder::SetTo(const media_format *output_format)
    4959{
    50     UNIMPLEMENTED();
    51     return B_OK;
     60    status_t err;
     61    media_codec_info codec_info;
     62    int32 cookie = 0;
     63
     64    err = get_next_encoder(&cookie, NULL, NULL, output_format, &codec_info, NULL, NULL);
     65    if(err != B_NO_ERROR)
     66        return err;
     67    return SetTo(&codec_info);
    5268}
    5369
    5470status_t
    5571BMediaEncoder::SetTo(const media_codec_info *mci)
    5672{
    57     UNIMPLEMENTED();
     73    _plugin_manager.DestroyEncoder(fEncoder);
     74    fEncoder = NULL;
     75   
     76    uint32 flags = 0;
     77    status_t err = _plugin_manager.CreateEncoder(&fEncoder, mci, flags);
     78    if (err < B_OK)
     79        goto fail;
     80
     81    err = AttachToEncoder();
     82    if (err < B_OK)
     83        goto fail;
     84
     85    fInitStatus = B_OK;
    5886    return B_OK;
     87
     88fail:
     89    _plugin_manager.DestroyEncoder(fEncoder);
     90    fEncoder = NULL;
     91    fInitStatus = B_NO_INIT;
     92    return err;
    5993}
    6094
    6195
     
    73107                      int64 frame_count,
    74108                      media_encode_info *info)
    75109{
    76     UNIMPLEMENTED();
    77     return B_OK;
     110    if (!fEncoder)
     111        return B_NO_INIT;
     112
     113    return fEncoder->Encode(buffer, frame_count, info);
    78114}
    79115
    80116
    81117status_t
    82118BMediaEncoder::GetEncodeParameters(encode_parameters *parameters) const
    83119{
    84     UNIMPLEMENTED();
    85     return B_OK;
     120    return fEncoder->GetEncodeParameters(parameters);
    86121}
    87122
    88123
    89124status_t
    90125BMediaEncoder::SetEncodeParameters(encode_parameters *parameters)
    91126{
    92     UNIMPLEMENTED();
    93     return B_OK;
     127    return fEncoder->SetEncodeParameters(parameters);
    94128}
    95129
    96130
     
    116150BMediaEncoder::BMediaEncoder & operator=(const BMediaEncoder &);
    117151*/
    118152
     153status_t
     154BMediaEncoder::AttachToEncoder()
     155{
     156    class MediaEncoderChunkWriter : public ChunkWriter {
     157    private:
     158        BMediaEncoder * fEncoder;
     159    public:
     160        MediaEncoderChunkWriter(BMediaEncoder * encoder) {
     161            fEncoder = encoder;
     162        }
     163        virtual status_t WriteChunk(const void* chunkBuffer, size_t chunkSize,
     164                                    media_encode_info* encodeInfo) {
     165            return fEncoder->WriteChunk(chunkBuffer, chunkSize, encodeInfo);
     166        }
     167    } * writer = new(std::nothrow) MediaEncoderChunkWriter(this);
     168   
     169    if (!writer)
     170        return B_NO_MEMORY;
     171   
     172    fEncoder->SetChunkWriter(writer);
     173    return B_OK;
     174}
     175
     176
    119177/* static */ status_t
    120178BMediaEncoder::write_chunk(void *classptr,
    121179                           const void *chunk_data,
     
    162220 *************************************************************/
    163221
    164222BMediaBufferEncoder::BMediaBufferEncoder()
     223    :   fBuffer(NULL)
    165224{
    166     UNIMPLEMENTED();
    167225}
    168226
    169227
    170228BMediaBufferEncoder::BMediaBufferEncoder(const media_format *output_format)
     229    :   fBuffer(NULL)
    171230{
    172     UNIMPLEMENTED();
    173231}
    174232
    175233
    176234BMediaBufferEncoder::BMediaBufferEncoder(const media_codec_info *mci)
     235    :   fBuffer(NULL)
    177236{
    178     UNIMPLEMENTED();
    179237}
    180238
    181239
     
    186244                                    int64 frame_count,
    187245                                    media_encode_info *info)
    188246{
    189     UNIMPLEMENTED();
    190 
    191     return B_ERROR;
     247    status_t error;
     248    fBuffer = output_buffer;
     249    fBufferSize = *output_size;
     250    error = Encode(input_buffer, frame_count, info);
     251    if(fBuffer) {
     252        fBuffer = NULL;
     253        *output_size = 0;
     254    }
     255    else {
     256        *output_size = fBufferSize;
     257    }
     258    return error;
    192259}
    193260
    194261
     
    201268                                size_t chunk_len,
    202269                                media_encode_info *info)
    203270{
    204     UNIMPLEMENTED();
    205 
    206     return B_ERROR;
     271    if(fBuffer == NULL)
     272        return B_ENTRY_NOT_FOUND;
     273    if((ssize_t)chunk_len < 0)
     274        return B_ERROR;
     275    if(chunk_len > (size_t)fBufferSize) {
     276        memcpy(fBuffer, chunk_data, fBufferSize);
     277        fBuffer = NULL;
     278        return B_DEVICE_FULL;
     279    }
     280    memcpy(fBuffer, chunk_data, chunk_len);
     281    fBufferSize = chunk_len;
     282    fBuffer = NULL;
     283    return B_NO_ERROR;
    207284}
    208285
    209286
  • headers/os/media/MediaEncoder.h

     
    88
    99#include <MediaFormats.h>
    1010
     11namespace BPrivate {
     12    class Encoder;
     13}
    1114
     15namespace BPrivate {
     16    namespace media {
     17        class Encoder;
     18        class EncoderPlugin;
     19    }
     20}
     21
    1222class BMediaEncoder {
    1323public:
    1424                                BMediaEncoder();
     
    6979                                    const void* buffer, size_t size,
    7080                                    media_encode_info* info);
    7181
     82            status_t            AttachToEncoder();
     83           
    7284            void                Init();
    7385            void                ReleaseEncoder();
    7486
    7587            uint32              _reserved_was_fEncoderMgr;
    76             uint32              _reserved_was_fEncoder;
     88//          uint32              _reserved_was_fEncoder;
     89            BPrivate::media::Encoder        *fEncoder;
    7790
    7891            int32               fEncoderID;
    7992            bool                fFormatValid;