Ticket #2970: media.diff

File media.diff, 9.1 KB (added by modeenf, 9 years ago)

First take :)

  • headers/os/media/MediaEncoder.h

    diff --git a/headers/os/media/MediaEncoder.h b/headers/os/media/MediaEncoder.h
    index 834bc73..68f4681 100644
    a b  
    88
    99#include <MediaFormats.h>
    1010
     11namespace BPrivate {
     12    class Encoder;
     13}
     14
     15namespace BPrivate {
     16    namespace media {
     17        class Encoder;
     18        class EncoderPlugin;
     19    }
     20}
    1121
    1222class BMediaEncoder {
    1323public:
    private:  
    6575            BMediaEncoder&      operator=(const BMediaEncoder& other);
    6676
    6777private:
     78    status_t                    _AttachToEncoder();
     79
    6880    static  status_t            write_chunk(void* classPtr,
    6981                                    const void* buffer, size_t size,
    7082                                    media_encode_info* info);
    private:  
    7385            void                ReleaseEncoder();
    7486
    7587            uint32              _reserved_was_fEncoderMgr;
    76             uint32              _reserved_was_fEncoder;
    77 
     88//          uint32              _reserved_was_fEncoder;
     89            BPrivate::media::Encoder        *fEncoder;
     90           
    7891            int32               fEncoderID;
    7992            bool                fFormatValid;
    8093            bool                fEncoderStarted;
  • src/kits/media/MediaEncoder.cpp

     
    diff --git a/src/kits/media/MediaEncoder.cpp b/src/kits/media/MediaEncoder.cpp
    index 6084920..64fcd04 100644
    a b  
    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
     8/*TO DO SetTo, SetFormat, Enode Class*/
    69#include <MediaEncoder.h>
     10#include <EncoderPlugin.h>
     11#include <PluginManager.h>
     12#include <new>
    713#include "debug.h"
    814
    9 
    1015/*************************************************************
    1116 * public BMediaEncoder
    1217 *************************************************************/
    1318
    1419BMediaEncoder::BMediaEncoder()
     20    :   fEncoder(NULL),
     21        fInitStatus(B_NO_INIT)
    1522{
    16     UNIMPLEMENTED();
     23    TRACE("BMediaEncoder::BMediaEncoder 1 enter\n");
    1724}
    1825
    1926
    2027BMediaEncoder::BMediaEncoder(const media_format *output_format)
     28    :   fEncoder(NULL),
     29        fInitStatus(B_NO_INIT)
    2130{
    22     UNIMPLEMENTED();
     31    TRACE("BMediaEncoder::BMediaEncoder 2 enter\n");
     32    SetTo(output_format);
    2333}
    2434
    2535
    2636BMediaEncoder::BMediaEncoder(const media_codec_info *mci)
     37    :   fEncoder(NULL),
     38        fInitStatus(B_NO_INIT)
    2739{
    28     UNIMPLEMENTED();
     40    TRACE("BMediaEncoder::BMediaEncoder 3 enter\n");
     41    SetTo(mci);
    2942}
    3043
    3144
    3245/* virtual */
    3346BMediaEncoder::~BMediaEncoder()
    3447{
    35     UNIMPLEMENTED();
     48    TRACE("BMediaEncoder::~BMediaEncoder enter\n");
     49    gPluginManager.DestroyEncoder(fEncoder);
     50    fEncoder = NULL;
    3651}
    3752
    3853
    3954status_t
    4055BMediaEncoder::InitCheck() const
    4156{
    42     UNIMPLEMENTED();
    43 
    44     return B_OK;
     57    TRACE("BMediaEncoder::InitCheck enter\n");
     58    return fInitStatus;
    4559}
    4660
     61
    4762status_t
    4863BMediaEncoder::SetTo(const media_format *output_format)
    4964{
    50     UNIMPLEMENTED();
     65    TRACE("BMediaEncoder::SetTo 1 enter\n");
     66    status_t err;
     67    media_codec_info codec_info;
     68    int32 cookie = 0;
     69
     70    while ((err = get_next_encoder(&cookie, NULL, NULL, output_format,
     71            &codec_info, NULL, NULL)) == B_OK) {
     72/*         printf(" %s / %s (%d)\n", mci.pretty_name, mci.short_name,
     73                  mci.id);*/
     74    }   
     75    if (err != B_OK)
     76        return err;
     77   
     78    return SetTo(&codec_info);
     79
     80/* My code to test.
     81    gPluginManager.DestroyEncoder(fEncoder);
     82    fEncoder = NULL;
     83
     84    status_t err = gPluginManager.CreateEncoder(&fEncoder, *output_format);
     85    if (err < B_OK)
     86        goto fail;
     87
     88    err = _AttachToEncoder();
     89    if (err < B_OK)
     90        goto fail;
     91
     92//  err = SetFormat(NULL, output_format); //Look at MediaDecoder
     93//  if (err < B_OK)
     94//      goto fail;
     95
     96    fInitStatus = B_OK;
    5197    return B_OK;
     98
     99fail:
     100    gPluginManager.DestroyEncoder(fEncoder);
     101    fEncoder = NULL;
     102    fInitStatus = B_NO_INIT;
     103    return err;*/
    52104}
    53105
     106
    54107status_t
    55108BMediaEncoder::SetTo(const media_codec_info *mci)
    56109{
    57     UNIMPLEMENTED();
     110    TRACE("BMediaEncoder::SetTo 2 enter\n");
     111    gPluginManager.DestroyEncoder(fEncoder);
     112    fEncoder = NULL;
     113
     114    //flags are not used but needed some how.
     115    status_t err = gPluginManager.CreateEncoder(&fEncoder, mci, 0);
     116    if (err < B_OK)
     117        goto fail;
     118
     119    err = _AttachToEncoder();
     120    if (err < B_OK)
     121        goto fail;
     122
     123    fInitStatus = B_OK;
    58124    return B_OK;
     125
     126fail:
     127    gPluginManager.DestroyEncoder(fEncoder);
     128    fEncoder = NULL;
     129    fInitStatus = B_NO_INIT;
     130    return err;
    59131}
    60132
    61133
    BMediaEncoder::SetFormat(media_format *input_format,  
    64136                         media_format *output_format,
    65137                         media_file_format *mfi)
    66138{
     139    TRACE("BMediaEncoder::SetFormat enter\n");
     140//  SetTo(output_format);
    67141    UNIMPLEMENTED();
    68142    return B_OK;
     143/*  if (!fEncoder)
     144        return B_NO_INIT;
     145
     146    media_format format = *in_format;
     147    return fEncoder->Setup(&format, in_info, in_size);*/
    69148}
    70149
     150
    71151status_t
    72152BMediaEncoder::Encode(const void *buffer,
    73153                      int64 frame_count,
    74154                      media_encode_info *info)
    75155{
    76     UNIMPLEMENTED();
    77     return B_OK;
     156    TRACE("BMediaEncoder::Encode enter\n");
     157    if (!fEncoder)
     158        return B_NO_INIT;
     159
     160    return fEncoder->Encode(buffer, frame_count, info);
    78161}
    79162
    80163
    81164status_t
    82165BMediaEncoder::GetEncodeParameters(encode_parameters *parameters) const
    83166{
    84     UNIMPLEMENTED();
    85     return B_OK;
     167    TRACE("BMediaEncoder::GetEncodeParameters enter\n");
     168    if (fEncoder == NULL)
     169        return B_NO_INIT;
     170    else
     171        return fEncoder->GetEncodeParameters(parameters);
    86172}
    87173
    88174
    89175status_t
    90176BMediaEncoder::SetEncodeParameters(encode_parameters *parameters)
    91177{
    92     UNIMPLEMENTED();
    93     return B_OK;
     178    TRACE("BMediaEncoder::SetEncodeParameters enter\n");
     179    if (fEncoder == NULL)
     180        return B_NO_INIT;
     181    else
     182        return fEncoder->SetEncodeParameters(parameters);
    94183}
    95184
    96185
    BMediaEncoder::SetEncodeParameters(encode_parameters *parameters)  
    101190/* virtual */ status_t
    102191BMediaEncoder::AddTrackInfo(uint32 code, const char *data, size_t size)
    103192{
    104     UNIMPLEMENTED();
    105     return B_OK;
     193    TRACE("BMediaEncoder::AddTrackInfo enter\n");
     194    if (fEncoder == NULL)
     195        return B_NO_INIT;
     196    else
     197        return fEncoder->AddTrackInfo(code, data, size);
    106198}
    107199
    108200
    BMediaEncoder::write_chunk(void *classptr,  
    122214                           size_t chunk_len,
    123215                           media_encode_info *info)
    124216{
    125     UNIMPLEMENTED();
    126     return B_OK;
     217    TRACE("BMediaEncoder::write_chunk enter\n");
     218    if (fEncoder == NULL)
     219        return B_NO_INIT;
     220       
     221    return fEncoder->WriteChunk(chunk_data, chunk_len, info);
    127222}
    128223
    129224
    130225void
    131226BMediaEncoder::Init()
    132227{
     228    TRACE("BMediaEncoder::Init enter\n");
    133229    UNIMPLEMENTED();
    134230}
    135231
    BMediaEncoder::Init()  
    137233void
    138234BMediaEncoder::ReleaseEncoder()
    139235{
     236    TRACE("BMediaEncoder::ReleaseEncoder enter\n");
    140237    UNIMPLEMENTED();
    141238}
    142239
     240
     241status_t
     242BMediaEncoder::_AttachToEncoder()
     243{
     244    class MediaEncoderChunkWriter : public ChunkWriter {
     245    private:
     246        BMediaEncoder* fEncoder;
     247    public:
     248        MediaEncoderChunkWriter(BMediaEncoder* encoder)
     249        {
     250            fEncoder = encoder;
     251        }
     252        virtual status_t WriteChunk(const void* chunkBuffer, size_t chunkSize,
     253                                    media_encode_info* encodeInfo)
     254        {
     255            return fEncoder->WriteChunk(chunkBuffer, chunkSize, encodeInfo);
     256        }
     257    }* writer = new(std::nothrow) MediaEncoderChunkWriter(this);
     258   
     259    if (!writer)
     260        return B_NO_MEMORY;
     261   
     262    fEncoder->SetChunkWriter(writer);
     263    return B_OK;
     264}
     265
     266
    143267status_t BMediaEncoder::_Reserved_BMediaEncoder_0(int32 arg, ...) { return B_ERROR; }
    144268status_t BMediaEncoder::_Reserved_BMediaEncoder_1(int32 arg, ...) { return B_ERROR; }
    145269status_t BMediaEncoder::_Reserved_BMediaEncoder_2(int32 arg, ...) { return B_ERROR; }
    status_t BMediaEncoder::_Reserved_BMediaEncoder_15(int32 arg, ...) { return B_ER  
    162286 *************************************************************/
    163287
    164288BMediaBufferEncoder::BMediaBufferEncoder()
     289    :   BMediaEncoder(),
     290        fBuffer(NULL)
    165291{
    166     UNIMPLEMENTED();
     292    TRACE("BMediaBufferEncoder::BMediaBufferEncoder enter\n");
    167293}
    168294
    169295
    170296BMediaBufferEncoder::BMediaBufferEncoder(const media_format *output_format)
     297    :   BMediaEncoder(output_format),
     298        fBuffer(NULL)
    171299{
    172     UNIMPLEMENTED();
     300    TRACE("BMediaBufferEncoder::BMediaBufferEncoder 1 enter\n");
    173301}
    174302
    175303
    176304BMediaBufferEncoder::BMediaBufferEncoder(const media_codec_info *mci)
     305    :   BMediaEncoder(mci),
     306        fBuffer(NULL)
    177307{
    178     UNIMPLEMENTED();
     308    TRACE("BMediaBufferEncoder::BMediaBufferEncoder 2 enter\n");
    179309}
    180310
    181311
    BMediaBufferEncoder::EncodeToBuffer(void *output_buffer,  
    186316                                    int64 frame_count,
    187317                                    media_encode_info *info)
    188318{
    189     UNIMPLEMENTED();
    190 
    191     return B_ERROR;
     319    TRACE("BMediaBufferEncoder::EncodeToBuffer enter\n");
     320    status_t error;
     321    fBuffer = output_buffer;
     322    fBufferSize = *output_size;
     323    error = Encode(input_buffer, frame_count, info);
     324    if (fBuffer) {
     325        fBuffer = NULL;
     326        *output_size = 0;
     327    } else {
     328        *output_size = fBufferSize;
     329    }
     330    return error;
    192331}
    193332
    194333
    BMediaBufferEncoder::WriteChunk(const void *chunk_data,  
    201340                                size_t chunk_len,
    202341                                media_encode_info *info)
    203342{
    204     UNIMPLEMENTED();
    205 
    206     return B_ERROR;
     343    TRACE("BMediaBufferEncoder::WriteChunk enter\n");
     344    if (fBuffer == NULL)
     345        return B_ENTRY_NOT_FOUND;
     346   
     347    if ((ssize_t)chunk_len < 0)
     348        return B_ERROR;
     349   
     350    if (chunk_len > (size_t)fBufferSize) {
     351        memcpy(fBuffer, chunk_data, fBufferSize);
     352        fBuffer = NULL;
     353        return B_DEVICE_FULL;
     354    }
     355   
     356    memcpy(fBuffer, chunk_data, chunk_len);
     357    fBufferSize = chunk_len;
     358    fBuffer = NULL;
     359    return B_NO_ERROR;
    207360}